ктото может помочь ускорить данный код?

[Poler]

            int k;
            int n = 0;
            int m = 0;
            int l = 0;
            List<int> A = new List<int> { };
            List<int> B = new List<int> { };
            List<int> C = new List<int> { };           
            List<int> D  = Console.ReadLine().Split().Select(int.Parse).ToList();

            // Заполняем первый массив до отрицательного числа
            while (l < D.Count)
            {
                k = D[l];
                l++;
                if (k < 0)
                {
                    break;
                }
                A.Add(k);
                n++;
            }
            // Заполняем второй массив до отрицательного числа
            while (l < D.Count)
            {
                k = D[l];
                l++;
                if (k < 0) break;
                B.Add(k);
                m++;
            }
            for (int i = 0; i < n; i++)
            {
                // Сравниваем очередной элемент первого массива с каждым элементом второго массива
                bool flag = false;
                for (int j = 0; j < m; j++)
                {
                    if (A[i] == B[j]) flag = true;
                }
                C.Add(flag ? 1 : 0);
            }
            C.Add(-1);
            for (int i = 0; i < C.Count-1; i++)
            {
                Console.Write(C[i].ToString() + " ");
            }
            Console.Write(C[C.Count-1]);

[BDA]

Как минимум, можно выходить из внутреннего цикла раньше:

if (A[i] == B[j]) {
    flag = true;
    break;
}

Вместо списка B использовать HashSet.

[G2250]

Можно отсортировать массив "В" в котором идет поиск, можно использовать IndexOf для поиска значения , можно проверять на минимальное/максимальное значение перед поиском.


using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApp_339950
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("введите 2 массива int c -1 (отрицательным числом) между массивами;");
string inputline = "0 10 11 22 33 44 777 8888 -1 77 89 22 10 44 55 66";

// inputline = Console.ReadLine();
// Console.WriteLine($"inputline = "{inputline}"");


int k;
int n = 0;
int m = 0;
int l = 0;
List<int> A = new List<int> { };
List<int> B = new List<int> { };
List<int> C = new List<int> { };
List<int> D = inputline.Split().Select(int.Parse) .ToList();

Console.WriteLine("D (входной список 2х массивов) :");
Console.Write("[ ");
foreach (int aa in D) { Console.Write($"{aa} "); };
Console.WriteLine("] \n\n");




// Заполняем первый массив до отрицательного числа
while (l < D.Count)
{
k = D[l];
l++;
if (k < 0)
{
break;
}
A.Add(k);
n++;
}
// Заполняем второй массив до отрицательного числа
while (l < D.Count)
{
k = D[l];
l++;
if (k < 0) break;
B.Add(k);
m++;
}



Console.WriteLine("A (первичный массив поисковые значения) :");
Console.Write("[ ");
foreach (int aa in A) { Console.Write($"{aa} "); };
Console.WriteLine("] \n\n");



Console.WriteLine("B (Значения где исчем) первично :");
Console.Write("[ ");
foreach (int bb in B) { Console.Write($"{bb} "); };
Console.WriteLine("] ");

B.Sort();


Console.WriteLine("B (Значения где исчем) отсортированно :");
Console.Write("[ ");
foreach (int bb in B) { Console.Write($"{bb} "); };
Console.WriteLine("] ");


// наименьше значение
int B_min;

// наибольшее значение
int B_max;

B_min = B[0];
B_max = B[B.Count -1];


Console.Write($"\n граничные значения B \n B_min={B_min}; B_max={B_max}; \n\n");




for (int i = 0; i < n; i++)
{
// Сравниваем очередной элемент первого массива с каждым элементом второго массива
bool flag = false;

int A_i = A[i];

if ((A_i>= B_min) && (A_i <= B_max)) // проверка что больше минимального значения и менее максимального
{
//for (int j = 0; j < m; j++) { if (A[i] == B[j]) flag = true; }

flag = (B.IndexOf(A_i) != (-1) );
}

C.Add(flag ? 1 : 0);
}
C.Add(-1);

Console.WriteLine("Итоги поиска:");
for (int i = 0; i < C.Count - 1; i++)
{
Console.WriteLine(A[i].ToString()+" -> "+(C[i] == 1 ? "1 найдено " : "0 - нет") + " ");
}


Console.Write(C[C.Count - 1]);

}
}
}

/*
Вывод программы
введите 2 массива int c -1 (отрицательным числом) между массивами;
D(входной список 2х массивов) :
[ 0 10 11 22 33 44 777 8888 -1 77 89 22 10 44 55 66 ]


A (первичный массив поисковые значения) :
[ 0 10 11 22 33 44 777 8888 ]


B (Значения где исчем) первично:
[ 77 89 22 10 44 55 66 ]
B(Значения где исчем) отсортированно:
[ 10 22 44 55 66 77 89 ]

граничные значения B
B_min=10; B_max = 89;

Итоги поиска:
0-> 0 - нет
10-> 1 найдено
11-> 0 - нет
22-> 1 найдено
33-> 0 - нет
44-> 1 найдено
777-> 0 - нет
8888-> 0 - нет
- 1
*/