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)