Determine duplicates based off minimum N characters from smaller comparing string

I assume that when the input contains 123 and 0123 you want the result to have both of them

var input = new List<Model>()
{
    new Model {ID = "123"},
    new Model {ID = "0123"},
    new Model {ID = "1230"},
    new Model {ID = "12"},
    new Model {ID = "122110123"}
};

var result = input.Where(x => input.Any(y => y != x && (y.ID.EndsWith(x.ID) || x.ID.EndsWith(y.ID)))).ToList();
\\this will return 123, 0123 and 122110123

If you want to check agains existing duplicateRecords list then this should work:

List<Model> modelRecords = testData.Models.Where(x => duplicateRecords.Any(y => x.ID.EndsWith(y) || y.EndsWith(x.ID))).ToList();

In order to efficiently find the duplicates you need to sort the IDs by length so you can minimize the comparisons necessary. (The sort adds some overhead, but greatly decreases the comparisons that must be done - in my test where 9 IDs have and 3 are duplicates of 8 values, it is 15 comparisons sorted versus 42 unsorted.) Once you have them sorted by length, just compare each one to the ones that are equal to or longer (in case of complete duplicates) to find which short IDs need to be kept, marking any matches so you can skip them and then find all the Models that end with the found matches.

Create the List of IDs ordered by their length:

var orderedIDs = testData.TestRecords.Select(tr => tr.ID).OrderBy(id => id.Length).ToList();

I don't think there is any way to do this efficiently with LINQ, but a nested for loop skipping previous matches optimizes the search for duplicates.

First, variables to keep track of IDsand whichID`s have already matched:

var dupRecordSubIDs = new List<string>();
var alreadyMatched = new bool[testData.TestRecords.Count];

Now loop through the IDs and save the shorter matching IDs:

// foreach ID in length order
for (int n1 = 0; n1 < testData.TestRecords.Count-1; ++n1) {
    // skip the ones that already matched a shorter ID
    if (!alreadyMatched[n1]) {
        // remember if the shorter ID was alrady added
        var added_n1 = false;
        // compare the ID to all greater than or equal length IDs
        for (int n2 = n1 + 1; n2 < testData.TestRecords.Count; ++n2) {
            // if not previously matched, see if we have a new match
            if (!alreadyMatched[n2] && orderedIDs[n2].EndsWith(orderedIDs[n1])) {
                // only add the shorter ID once for new matches
                if (!added_n1) {
                    dupRecordSubIDs.Add(orderedIDs[n1]);
                    added_n1 = true;
                }
                // remember which longer IDs are already matched
                alreadyMatched[n2] = true;
            }
        }
    }
}

Now find all the Models that match one of the IDs with a duplicate:

var modelRecords = testData.Models.Where(m => dupRecordSubIDs.Any(d => m.ID.EndsWith(d))).ToList();

I assume ID is string. If so, you can do this :

string match = "123";

var duplicate = list.Where(x=> x.Substring(x.Length - match.Length) == match).ToList();

If I understand your question correctly, it looks to be just a matter of chopping off the last N characters in each ID property while grouping.

Something like this:

using System;
using System.Linq;

public class TestRecord
{
    public string ID { get; set; }
}

public class TestModel
{
    public string ID { get; set; }
}

public class Program
{
    public static void Main()
    {
        var N = 3; // This is where you define the desired N length
        var rand = new Random();

        var testRecords =  new TestRecord[]
        {
            new TestRecord {ID = "123"},
            new TestRecord {ID = "0123"},
            new TestRecord {ID = "1230"},
            new TestRecord {ID = "122110123"},
        };

        var testModels = new TestModel[]
        {
            new TestModel {ID = "123"},
            new TestModel {ID = "0123"},
            new TestModel {ID = "1230"},
            new TestModel {ID = "122110123"},
        };

        bool SortEm(string a, string b) => a.Length < b.Length ? b.EndsWith(a) : a.EndsWith(b);

        var models = testRecords
            .Where(record => testRecords.Any(target => record.ID != target.ID && SortEm(target.ID, record.ID)))
            .ToDictionary(
                key => key, 
                key => testModels.Where(testModel => SortEm(key.ID, testModel.ID)).ToArray());

        foreach (var kvp in models)
        {
            System.Console.WriteLine($"For duplicate key ({kvp.Key.ID}) found models: \r\n\t{string.Join("\r\n\t", kvp.Value.Select(x => x.ID))}");
        }
    }
}