Welcome to the Lounge

using System;
using System.Collections.Generic;

namespace ConsoleApp3
{
    class Program
    {
        static void Main(string[] args)
        {
            // prep the data
            Parts nuts = new Parts();
            Parts bolts = new Parts(nuts);

            nuts.Sort();
            bolts.Sort();

            foreach(Part nut in nuts)
            {
                Part bolt = bolts[nuts.IndexOf(nut)];
                Console.WriteLine("Pair: [{0}] - [{1}]", nut, bolt);
            }
            Console.ReadKey();
        }
    }

    public enum HardwareType { BOLT=0, NUT}

    /// The "part" (all parts have a hardware type, a diameter and pitch)
    public class Part : IComparable<Part>
    {
        public HardwareType Hardware { get; set; }
        public int ItemID { get; set; }
        public int Diameter { get; set; }
        public int Pitch { get; set; }
        public Part(int itemID, int diameter, int pitch, HardwareType hardware)
        {
            this.ItemID   = itemID;
            this.Diameter = diameter;
            this.Pitch    = pitch;
            this.Hardware = hardware;
        }

        public int CompareTo(Part p)
        {
            return this.Diameter.CompareTo(p.Diameter);
        }

        // make it more convenient to look at in the debugger
        public override string ToString()
        {
            return string.Format("{0}, ID={1}, D={2}, P={3}", this.Hardware.ToString(), this.ItemID, this.Diameter, this.Pitch);
        }
    }

    public class Parts : List<Part>
    {
        // This constructor builds a collection of nuts
        public Parts(bool populate=true)
        {
            if (populate)
            {
                // create a list of "part"s with randomly selected combinations of diameter and pitch
                List<int> diameters = new List<int>(){  1, 2, 3, 4, 5, 6, 7, 8, 9,10 };
                List<int> pitches   = new List<int>(){ 11,12,13,14,15,16,17,18,19,20 };
                Random    diaRandom = new Random(1);
                Random    pitRandom = new Random(3);
                int diaIndex;
                int pitIndex;
                int id = 0;
                do
                {
                    diaIndex = diaRandom.Next(0, diameters.Count-1);
                    pitIndex = pitRandom.Next(0, pitches.Count-1);
                    this.Add(new Part(id, diameters[diaIndex], pitches[pitIndex], HardwareType.NUT));
                    diameters.RemoveAt(diaIndex);
                    pitches.RemoveAt(pitIndex);
                    id++;
                } while (diameters.Count > 1);
                this.Add(new Part(id, diameters[0], pitches[0], HardwareType.NUT));
                diameters.RemoveAt(0);
                pitches.RemoveAt(0);
            }
        }

        // this constructor build acollection of bolts based on the nuts collection provided.
        public Parts(Parts parts)
        {
            // we can't randoly select dia/pitch again, and we can't randmly select nuts and 
            // delete them from the list without destroying the original list, so we clone 
            // the colllection of nuts
            Parts cloned = new Parts(false);
            cloned.AddRange(new List<Part>(parts));

            // and now we can rendomly select a nut from the cloned collection
            Random random = new Random();
            int index;
            int id = 0;
            do
            {
                index = random.Next(0,cloned.Count-1);
                this.Add(new Part(id, cloned[index].Diameter, cloned[index].Pitch, HardwareType.BOLT));
                cloned.RemoveAt(index);
                id++;
            } while (cloned.Count > 1);
            this.Add(new Part(id, cloned[0].Diameter, cloned[0].Pitch, HardwareType.BOLT));
            cloned.RemoveAt(0);
        }
    }
}

foreach(Part nut in nuts)
{
    foreach (Part bolt in bolts)
    {
        if (nut.Diameter == bolt.Diameter && nut.Pitch == bolt.Pitch)
        {
            Console.WriteLine("Pair: [{0}] - [{1}]", nut, bolt);
        }
    }
}

class predicates
    match : (integer_list NutSizes, integer_list BoltSizes, integer_list CurrentMatches) -> integer_list SizesMatched.
clauses
    match([], [], RevMM) = list::reverse(RevMM) :-
        !.
    match(NN, BB, CurrMM) = MM :-
        N in NN,
        B in BB,
        N = B,
        !,
        UnatchedNN = list::remove(NN, N),
        UnatchedBB = list::remove(BB, N),
        write("\nUnmatched Nuts:  ", NN),
        write("\nUnmatched Bolts: ", BB),
        write("\nCurrent matches: ", [N | CurrMM]),
        MM = match(UnatchedNN, UnatchedBB, [N | CurrMM]).
    match(_, _, _) = [] :-
        exception::raise_error("Input lists contain an unmatched item or list lengths are unequal.").

domains
    itemDOM = item(integer ID, integer Size).

class predicates
    matchItems : (itemDOM* Nuts, itemDOM* Bolts, tuple{itemDOM Nut, itemDOM Bolt}*) -> tuple{itemDom Nut, itemDOM BoltID}*.
clauses
    matchItems([], [], RevMM) = list::reverse(RevMM) :-
        !.
    matchItems(NN, BB, CurrItems) = MM :-
        item(IdN, SizeN) in NN,
        item(IdB, SizeB) in BB,
        SizeN = SizeB,
        !,
        UnmatchedNN = list::remove(NN, item(IdN, SizeN)),
        UnmatchedBB = list::remove(BB, item(IdB, SizeB)),
        MM = matchItems(UnmatchedNN, UnmatchedBB, [tuple(item(IdN, SizeN), item(IdB, SizeB)) | CurrItems]).
    matchItems(_, _, _) = [] :-
        exception::raise_error("Input lists contain an unmatched item or list lengths are unequal.").

clauses
    run() :-
        write("\n\n", "Testing", "\n\n"),
        IDs = mkList(5, []), % create a list of 5 random integers
        NutItems = [ item(ID, ID * 100) || ID in IDS ], % set sizes to be 5 X the ID
        BoltItems = [ item(ID + 300, Size) || item(ID, Size) in NutItems ], % set Bolt IDs to 300 greater than Nut IDs
        MM = matchItems(NutItems, BoltItems, []),
        write(MM),
        write("\nPress [Enter] to exit"),
        _ = readLine(),
        !.

// Z = Number of nuts/bolts, N[1..Z], B[1..Z] hold the nuts/bots

For X = 1 to Z
  For Y = 1 to Z
    If Fits(B[X],N[Y]) then F[X]=Y : Break;
  Next Y
Next X

For X = 1 to Z
  Print "Bolt " & X & " Fits with Nut " & F[X]
Next X

// Accepting that if the output is all that is needed, do the print in the main loop, before the break;
// If "Fits()" is an expensive function, then pre-check F[X] for 0 or something to skip it if assigned

// No optimizations here.  But short, clear, concise.
// Simplest optimization is to process the second loop in reverse, deleting an element as it is matched

// The list of Nuts will shrink by one with each pass, cutting the comparisons in half.
// Unfortunately requires a modifiable array.

For X = 1 to Z
  For Y = Length(N) to 1 Step -1
    If Fits(B[X],N[Y]) then F[X]=Y :  N.delete(Y) : Break;
  Next Y
Next X

int boltDiameters[n]  // Resizable array
int nutDiameters[n]   // Resizable array

do {
    boltsize = boltDiameters[0]
    for (int i = 0; i < nutDiameters.Length; i++) {
       if (nutDiameters[i] == boltsize) {
            println("Found nut-bolt with size of: " + boltsize)
            nutDiameters.RemoveAt(i)
            boltDiameters.RemoveAt(0)
       }
    }   
} Until (boltDiameters.Length == 0)

Algorithm:
I assume that separating the "pile of N nuts and N bolts" into a pile of nuts and a pile of bolts is allowed.
  I wrote a Nut class and a Bolt class (both deriving from a Base class).
  I wrote a NutList class and a BoltList class (both deriving from a BaseList class).
    These hold a "pile" of Nuts or Bolts.
    The lists can be Shuffled to simulate drawing one item at random, as you would from an actual pile.
If you were actually performing this task (during an interview perhaps), you might have some divided disposable plates on hand.
  One common type of disposable plate for low-class dinner parties has a large section and two small sections.
  I wrote a Tray class to represent this; it can hold one Nut, one Bolt, and one NutList (pile of Nuts).

Diagram of a Tray:
__________________________
|                        |
|                        |
| Pile of unmatched Nuts |
|                        |
|________________________|
|            |           |
| Matched    | Matched   |
| Nut        | Bolt      |
|____________|___________|

You could use a number of these disposable plates -- one for each nut-and-bolt you have matched up and that subset of the Nuts which are "larger" than them.
  I wrote a TrayList class to hold an ordered list of Trays.
  A TrayList begins with one item, containing a "null" nut-and-bolt, which is guaranteed to test "smaller" than all other Nuts and Bolts.

0) Begin with a pile of all of the Nuts on the "null" Tray and a pile of all the of Bolts.
1) Draw one Bolt from the pile of Bolts.
2) Beginning with the "null" Tray, compare the Bolt with the (matched) Nuts on the Trays in front of you.
2.1) When you reach the end of the Trays or a Tray with a "larger" Nut, that's where you want to insert a new Tray for this Bolt.
3) Create a new Tray, put the Bolt on it, shift any "larger" Trays to the right, and insert the new Tray.
4) Test each Nut in the pile of (unmatched) Nuts on the Tray to the left of the new Tray against the Bolt.
4.1) Any Nuts which are "larger" than the Bolt get moved to the new Tray's pile of (unmatched) Nuts.
4.2) When you find the Nut which matches the Bolt, move it to the Tray.
4.3) Any Nuts which are "smaller" than the Bolt remain where they are.
5) If there are more Bolts to match, repeat from 1)
6) Done.

namespace PIEBALD
{
  public static partial class Tester
  {
    public static int
    Main
    (
      string[] args
    )
    {
      int result = 0 ;

      /* "1/8"" "1/4"" "3/8"" "1/2"" "5/8"" "3/4"" "7/8"" "1"" */
      System.Collections.Generic.IList<NutAndBolt.Pair> list = NutAndBolt.Run ( args ) ;

      for ( int i = 0 ; i < list.Count ; i++ )
      {
        System.Console.WriteLine
        (
          "{0,2} : {1}"
        ,
          i
        ,
          list [ i ]
        ) ;
      }

      return ( result ) ;
    }
  }

  public static partial class NutAndBolt
  {
    public sealed partial class Pair
    {
      public Nut  Nut  { get ; private set ; }
      public Bolt Bolt { get ; private set ; }

      public Pair
      (
        Nut  Nut
      ,
        Bolt Bolt
      )
      {
        if ( Nut.CompareTo ( Bolt ) != 0 )
        {
          throw ( new System.Exception ( "" ) ) ;
        }

        this.Nut  = Nut  ;
        this.Bolt = Bolt ;

        return ;
      }

      public override string
      ToString
      (
      )
      {
        return ( System.String.Format
        ( 
          "{0} Nut and {1} Bolt"
        ,
          this.Nut.Description
        ,
          this.Bolt.Description
        ) ) ;
      }
    }

    public static System.Collections.Generic.IList<Pair>
    Run
    (
      params string[] Description
    )
    {
      System.Collections.Generic.List<Pair> result = 
        new System.Collections.Generic.List<Pair> ( Description.Length ) ;

      BoltList boltlist = new BoltList ( Description.Length ) ;

      TrayList traylist = new TrayList ( Description.Length ) ;

      NutList nutlist = traylist [ 0 ].NutList ;

      for ( int i = 0 ; i < Description.Length ; i++ )
      {
        nutlist.Add  ( new Nut  ( i , Description [ i ] ) ) ;
        boltlist.Add ( new Bolt ( i , Description [ i ] ) ) ;
      }

      nutlist.Shuffle() ;
      boltlist.Shuffle() ;

      Resolve ( traylist , boltlist ) ;

      for ( int i = 1 ; i < traylist.Count ; i++ )
      {
        result.Add ( new Pair ( traylist [ i ].Nut , traylist [ i ].Bolt ) ) ;
      }

      return ( result.AsReadOnly() ) ;
    }

    private static int
    Resolve
    (
      TrayList TrayList
    ,
      BoltList BoltList
    )
    {
      for ( int b = BoltList.Count - 1 ; b >= 0 ; b-- )
      {
        int t = TrayList.Insert ( BoltList [ b ] ) ;

        Tray tray = TrayList [ t ] ;

        NutList nutlist = TrayList [ t - 1 ].NutList ;

        for ( int n = nutlist.Count - 1 ; n >= 0 ; n-- )
        {
          int d = nutlist [ n ].CompareTo ( tray.Bolt ) ;

          if ( d > 0 )
          {
            tray.NutList.Add ( nutlist.Fetch ( n ) ) ;
          }
          else if ( d == 0 )
          {
            tray.AddNut ( nutlist.Fetch ( n ) ) ;
          }
        }
      }

      return ( TrayList.Count ) ;
    }

    public abstract partial class Base
    {
      private int    ID          ;
      public  string Description { get ; private set ; }

      protected Base
      (
        int    ID 
      ,
        string Description 
      )
      {
        if ( System.String.IsNullOrWhiteSpace ( Description ) && ( ID != -1 ) )
        {
          throw ( new System.Exception ( "" ) ) ;
        }

        this.ID          = ID          ;
        this.Description = Description ;

        return ;
      }

      protected static int
      Compare
      (
        Base Op0
      ,
        Base Op1
      )
      {
        return ( Op0.ID.CompareTo ( Op1.ID ) ) ;
      }
    }

    private abstract partial class BaseList<T> : System.Collections.Generic.List<T> 
      where T : Base
    {
      protected BaseList
      (
        int Capacity
      )
      : base
      (
        Capacity
      )
      {
        return ;
      }

      public virtual void
      Shuffle
      (
      )
      {
        for ( int i = this.Count ; i > 0 ; i-- )
        {
          int j = Random.Next ( i ) ;

          T n = this [ j ] ;

          this.RemoveAt ( j ) ;

          this.Add ( n ) ;
        }

        return ;
      }

      /* Removes and returns the specified item */
      protected virtual B
      Fetch<B>
      (
        int Index
      )
      where B : Base
      {
        B result = this [ Index ] as B ;

        this.RemoveAt ( Index ) ;

        return ( result ) ;
      }
    }

    public sealed partial class Nut : Base , System.IComparable<Bolt>
    {
      public Nut
      (
        int    ID 
      ,
        string Descrption 
      )
      : base
      (
        ID 
      ,
        Descrption 
      )
      {
        return ;
      }

      public int
      CompareTo
      (
        Bolt Bolt
      )
      {
        return ( Compare ( this , Bolt ) ) ;
      }
    }

    private sealed partial class NutList : BaseList<Nut> 
    {
      public NutList
      (
        int Capacity
      )
      : base
      (
        Capacity
      )
      {
        return ;
      }

      /* Removes and returns the specified Nut */
      public Nut
      Fetch
      (
        int Index
      )
      {
        return ( this.Fetch<Nut> ( Index ) ) ;
      }
    }

    public sealed partial class Bolt : Base , System.IComparable<Nut>
    {
      public Bolt
      (
        int    ID 
      ,
        string Descrption 
      )
      : base
      (
        ID 
      ,
        Descrption 
      )
      {
        return ;
      }

      public int
      CompareTo
      (
        Nut Nut
      )
      {
        return ( Compare ( this , Nut ) ) ;
      }
    }

    private sealed partial class BoltList : BaseList<Bolt> 
    {
      public BoltList
      (
        int Capacity
      )
      : base
      (
        Capacity
      )
      {
        return ;
      }

      /* Removes and returns the specified Bolt */
      public Bolt
      Fetch
      (
        int Index
      )
      {
        return ( this.Fetch<Bolt> ( Index ) ) ;
      }
    }

    private sealed partial class Tray
    {
      public Nut     Nut     { get ; private set ; }
      public Bolt    Bolt    { get ; private set ; }

      public NutList NutList { get ; private set ; }

      public Tray
      (
        Bolt Bolt
      ,
        int Capacity
      )
      {
        if ( Bolt == null ) throw ( new System.Exception() ) ;

        this.Bolt = Bolt ;

        this.NutList = new NutList ( Capacity ) ;

        return ;
      }

      public void
      AddNut
      (
        Nut Nut
      )
      {
        if ( Nut == null ) throw ( new System.Exception() ) ;
        if ( this.Nut != null ) throw ( new System.Exception() ) ;

        this.Nut = Nut ;

        return ;
      }
    }

    private sealed partial class TrayList
    {
      private System.Collections.Generic.List<Tray> list ;

      public TrayList
      (
        int Capacity
      )
      {
        this.list = new System.Collections.Generic.List<Tray> ( Capacity ) ;

        /* Tray 0 is the "null tray" */
        Tray tray = new Tray ( new Bolt ( -1 , null ) , Capacity ) ;
        tray.AddNut ( new Nut ( -1 , null ) ) ;
        this.list.Add ( tray ) ;

        return ;
      }

      public int
      Count
      {
        get
        {
          return ( this.list.Count ) ;
        }
      }

      /* TrayList is sorted by Nut and Bolt size */
      public int
      Insert
      (
        Bolt Bolt
      )
      {
        int result = 0 ;

        if ( Bolt == null ) throw ( new System.Exception() ) ;

        /* Could be replaced with a binary search if we expected a large number of Trays */
        while
        (
          ( result < this.Count )
        && 
          ( this.list [ result ].Nut.CompareTo ( Bolt ) < 0 )
        )
        {
          result++ ;
        }        

        this.list.Insert ( result , new Tray ( Bolt , this.list [ result - 1 ].NutList.Count ) ) ;

        return ( result ) ;
      }

      public Tray
      this
      [
        int Index
      ]
      {
        get
        {
          return ( this.list [ Index ] ) ;
        }
      }
    }

    private static partial class Random
    {
      private static System.Random rnd ;

      static Random
      (
      )
      {
        rnd = new System.Random ( (int) System.DateTime.Now.Ticks ) ;

        return ;
      }

      public static int
      Next
      (
        int Max
      )
      {
        for ( int i = System.DateTime.Now.Millisecond / 100 ; i > 0 ; i-- )
        {
          rnd.Next() ;
        }

        return ( rnd.Next ( Max ) ) ;
      }
    }
  }
}