Смешайте в списке общие и необычные числа в пределах диапазона, отмеченного первым списком [дубликаты]

Хорошо, я переосмыслил вопрос

У меня есть список:

[- 0,5, -0,4, -0,1, 0, 1,0, 2,0, 3,0, 2,0, 1,0, 0, -0,2, -0,3 -0,5]

и другие списки:

[-0,3, -0,1, 0, 1,2, 2,0, 2,3, 2,0, 1,5, 0, -0,1, -0,3 -0,5]

конечным результатом должна быть смесь этих двух при сохранении порядок:

[- 0,5, -0,4, -0,3, -0,1, 0, 1,0, 1,2, 2,0, 2,3, 3,0, 2,0, 1,0, 0, -0,1, -0,2, -0,3 , -0,5]

Эти значения соответствуют координатному значению X, это круговая кривая

-n, ..., 0, ... , n, ..., 0, ..., -n

 int contadorA = 0;
        int contadorB = 0;
        double extremoIzquierdo = lListaAOriginal[0].CoordenadaX;
        double extremoDerecho = lListaAOriginal[lListaAOriginal.Count - 1].CoordenadaX;
        /*
        foreach (Dato daux in lListaBOriginal.ToList())
        {
            if (daux.CoordenadaX < 0)
            {
                if (daux.CoordenadaX < extremoIzquierdo)
                {
                    lListaBOriginal.Remove(daux);
                }
            }
            if (daux.CoordenadaX > 0)
            {
                if (daux.CoordenadaX > extremoIzquierdo)
                {
                    lListaBOriginal.Remove(daux);
                }
            }
        }*/

        Dato primeroA = lListaAOriginal[0];

        List<Dato> lista1Ascendente = new List<Dato>();
        lista1Ascendente.Add(primeroA);
        List<Dato> lista1Descendente = new List<Dato>();
        int contador = 0;
        foreach (Dato daux in lListaAOriginal.ToList())
        {
            if (daux.CoordenadaX > primeroA.CoordenadaX)
            {
                lista1Ascendente.Add(daux);
                primeroA = daux;
                contador++;
            }
        }
        for (int i = contador+1; i <= lListaAOriginal.Count - 1; i++)
        {
            lista1Descendente.Add(lListaAOriginal[i]);
        }



        Dato primeroB = lListaBOriginal[0];

        List<Dato> lista2Ascendente = new List<Dato>();
        lista2Ascendente.Add(primeroB);
        List<Dato> lista2Descendente = new List<Dato>();
        contador = 0;
        foreach (Dato daux in lListaBOriginal.ToList())
        {
            if (daux.CoordenadaX > primeroB.CoordenadaX)
            {
                lista2Ascendente.Add(daux);
                primeroB = daux;
                contador++;
            }
        }
        for (int i = contador + 1; i <= lListaBOriginal.Count - 1; i++)
        {
            lista2Descendente.Add(lListaBOriginal[i]);
        }


        for (int i = 0; i <= lista1Ascendente.Count - 1; i++)
        {
            for (int j = 0; j <= lista2Ascendente.Count - 1; j++)
            {

                if (lista1Ascendente[i].CoordenadaX < lista2Ascendente[j].CoordenadaX)
                {

                    if (!lista1Ascendente[i].Error1)
                    {
                        nuevaListaA.Add(lista1Ascendente[i]);
                        lista1Ascendente[i].Error1 = true;
                        auxDato = new Dato();
                        if (lista1Ascendente[i].CoordenadaX < lista2Ascendente[0].CoordenadaX)
                        {
                            auxDato.CoordenadaY = ((lista2Ascendente[1].CoordenadaY - lista2Ascendente[0].CoordenadaY) / (lista2Ascendente[1].CoordenadaX - lista2Ascendente[0].CoordenadaX))
                                * (lista1Ascendente[i].CoordenadaX - lista2Ascendente[0].CoordenadaX) + lista2Ascendente[0].CoordenadaY;
                            auxDato.CoordenadaX = lista1Ascendente[i].CoordenadaX;
                        }
                        else
                        {
                            auxDato.CoordenadaY = ((lista2Ascendente[j].CoordenadaY - lista2Ascendente[j - 1].CoordenadaY) / (lista2Ascendente[j].CoordenadaX - lista2Ascendente[j - 1].CoordenadaX))
                                * (lista1Ascendente[i].CoordenadaX - lista2Ascendente[j - 1].CoordenadaX) + lista2Ascendente[j - 1].CoordenadaY;
                            auxDato.CoordenadaX = lista1Ascendente[i].CoordenadaX;
                        }
                        nuevaListaB.Add(auxDato);
                    }


                }
                else if (lista1Ascendente[i].CoordenadaX > lista2Ascendente[j].CoordenadaX)
                {

                    if (!lista2Ascendente[j].Error1)
                    {
                        auxDato = new Dato();
                        auxDato.CoordenadaY = ((lista1Ascendente[i].CoordenadaY - lista1Ascendente[i - 1].CoordenadaY) / (lista1Ascendente[i].CoordenadaX - lista1Ascendente[i - 1].CoordenadaX))
                        * (lista2Ascendente[j].CoordenadaX - lista1Ascendente[i - 1].CoordenadaX) + lista1Ascendente[i - 1].CoordenadaY;
                        auxDato.CoordenadaX = lista2Ascendente[j].CoordenadaX;
                        nuevaListaA.Add(auxDato);

                        nuevaListaB.Add(lista2Ascendente[j]);
                        lista2Ascendente[j].Error1 = true;
                    }


                }
                else if (lista1Ascendente[i].CoordenadaX == lista2Ascendente[j].CoordenadaX)
                {
                    if (!lista2Ascendente[j].Error1 && !lista1Ascendente[i].Error1)
                    {
                        lista2Ascendente[j].Error1 = true;
                        lista1Ascendente[i].Error1 = true;
                        nuevaListaA.Add(lista1Ascendente[i]);
                        nuevaListaB.Add(lista2Ascendente[j]);
                    }

                }
                else
                {
                    nuevaListaA.Add(lista1Ascendente[i]);
                    lista1Ascendente[i].Error1 = true;
                    auxDato = new Dato();
                    auxDato.CoordenadaY = ((nuevaListaB[nuevaListaB.Count - 1].CoordenadaY - nuevaListaB[nuevaListaB.Count - 2].CoordenadaY) / (nuevaListaB[nuevaListaB.Count - 1].CoordenadaX - nuevaListaB[nuevaListaB.Count - 2].CoordenadaX))
                                    * (lista1Ascendente[i].CoordenadaX - nuevaListaB[nuevaListaB.Count - 2].CoordenadaX) + nuevaListaB[nuevaListaB.Count - 2].CoordenadaY;
                    auxDato.CoordenadaX = lista1Ascendente[i].CoordenadaX;

                    nuevaListaB.Add(auxDato);
                }




            }

        }


        for (int i = 0; i <= lista1Descendente.Count - 1; i++)
        {
            for (int j = 0; j <= lista2Descendente.Count - 1; j++)
            {

                if (lista1Descendente[i].CoordenadaX > lista2Descendente[j].CoordenadaX)
                {

                    if (!lista1Descendente[i].Error1)
                    {
                        nuevaListaA.Add(lista1Descendente[i]);
                        lista1Descendente[i].Error1 = true;
                        auxDato = new Dato();
                        if (lista1Descendente[i].CoordenadaX < lista2Descendente[0].CoordenadaX)
                        {
                            auxDato.CoordenadaY = ((lista2Descendente[1].CoordenadaY - lista2Descendente[0].CoordenadaY) / (lista2Descendente[1].CoordenadaX - lista2Descendente[0].CoordenadaX))
                                * (lista1Descendente[i].CoordenadaX - lista2Descendente[0].CoordenadaX) + lista2Descendente[0].CoordenadaY;
                            auxDato.CoordenadaX = lista1Descendente[i].CoordenadaX;
                        }
                        else
                        {
                            //auxDato.CoordenadaY = ((lista2Descendente[j].CoordenadaY - lista2Descendente[j - 1].CoordenadaY) / (lista2Descendente[j].CoordenadaX - lista2Descendente[j - 1].CoordenadaX))
                            //    * (lista1Descendente[i].CoordenadaX - lista2Descendente[j - 1].CoordenadaX) + lista2Descendente[j - 1].CoordenadaY;
                            auxDato.CoordenadaX = lista1Descendente[i].CoordenadaX;
                        }
                        nuevaListaB.Add(auxDato);
                    }


                }
                else if (lista1Descendente[i].CoordenadaX < lista2Descendente[j].CoordenadaX)
                {

                    if (!lista2Descendente[j].Error1)
                    {
                        auxDato = new Dato();
                        auxDato.CoordenadaY = ((lista1Descendente[i].CoordenadaY - lista1Descendente[i - 1].CoordenadaY) / (lista1Descendente[i].CoordenadaX - lista1Descendente[i - 1].CoordenadaX))
                        * (lista2Descendente[j].CoordenadaX - lista1Descendente[i - 1].CoordenadaX) + lista1Descendente[i - 1].CoordenadaY;
                        auxDato.CoordenadaX = lista2Descendente[j].CoordenadaX;
                        nuevaListaA.Add(auxDato);
                        nuevaListaB.Add(lista2Descendente[j]);
                        lista2Descendente[j].Error1 = true;
                    }


                }
                else if (lista1Descendente[i].CoordenadaX == lista2Descendente[j].CoordenadaX)
                {
                    if (!lista2Descendente[j].Error1 && !lista1Descendente[i].Error1)
                    {
                        lista2Descendente[j].Error1 = true;
                        lista1Descendente[i].Error1 = true;
                        nuevaListaA.Add(lista1Descendente[i]);
                        nuevaListaB.Add(lista2Descendente[j]);
                    }

                }
                else
                {
                    nuevaListaA.Add(lista1Descendente[i]);
                    lista1Descendente[i].Error1 = true;
                    auxDato = new Dato();
                    auxDato.CoordenadaY = ((nuevaListaB[nuevaListaB.Count - 1].CoordenadaY - nuevaListaB[nuevaListaB.Count - 2].CoordenadaY) / (nuevaListaB[nuevaListaB.Count - 1].CoordenadaX - nuevaListaB[nuevaListaB.Count - 2].CoordenadaX))
                                    * (lista1Descendente[i].CoordenadaX - nuevaListaB[nuevaListaB.Count - 2].CoordenadaX) + nuevaListaB[nuevaListaB.Count - 2].CoordenadaY;
                    auxDato.CoordenadaX = lista1Descendente[i].CoordenadaX;

                    nuevaListaB.Add(auxDato);
                }




            }

        }

        foreach (Dato daux in lista1Descendente.ToList())
        {
            if (!daux.Error1)
            {
                nuevaListaA.Add(daux);
                daux.Error1 = true;
                auxDato = new Dato();
                auxDato.CoordenadaY = ((nuevaListaB[nuevaListaB.Count - 1].CoordenadaY - nuevaListaB[nuevaListaB.Count - 2].CoordenadaY) / (nuevaListaB[nuevaListaB.Count - 1].CoordenadaX - nuevaListaB[nuevaListaB.Count - 2].CoordenadaX))
                                * (daux.CoordenadaX - nuevaListaB[nuevaListaB.Count - 2].CoordenadaX) + nuevaListaB[nuevaListaB.Count - 2].CoordenadaY;
                auxDato.CoordenadaX = daux.CoordenadaX;

                nuevaListaB.Add(auxDato);
            }
        }
-1
задан 11.01.2017, 11:48
0 ответов

Эта проблема ты можешь решать это легко с алгоритмом типа "Mergesort".

Алгоритм обычно используется для того, чтобы упорядочивать неряшливые списки, и то, что ты делаешь, первое отделять список в отрывках, и потом объединять их поддерживая порядок.

Для твоей проблемы ты будешь должен касаться немного алгоритма так что я уважал тебя, что список сначала восходящий и потом нисходящий.

Я, кто ты, он разделил бы каждый список на 2 части, Lista1Ascendente, Lista1Descendente, Lista2Ascendente и Lista2Descendente. С этим, я перемешиваю два восходящих списка и две нисходящих, оставляя себе единственный восходящий список и единственный нисходящий список. Тогда просто ты прилагаешь список с другой и у тебя есть твое решение.

0
ответ дан 03.12.2019, 17:47