[C#] operazioni con array

[cyberwolf4ever]

salve a tutti...
ho un array di interi ordinati in maniera crescente ogni volta variabile...

ho bisogno di fare questa cosa...
quando 2 valori dell'array sono relativamente contigui (uno scarto di circa 30 unità), il valore più piccolo devo impostarlo come iniziale e quello più grande come finale, ovviamente riducendo la dimensione dell'array

avrei in mente il metodo, ma non riesco a buttare giu due linee di codice...

vi faccio un esempio di come avevo in mente di fare...

l'array principale è formato da 5 elementi... [1; 60; 125; 134; 255]

prima di eseguire la lettura dell'array, creo 2 array (o liste) chiamate inizio e fine

quando lo scarto tra 2 elementi è maggiore di 30, per esempio 1 e 60, al primo posto utile dei 2 array, l'algoritmo dovrebbe inserire sia in inizio che in fine lo stesso valore... nel caso in cui invece, la differenza è inferiore a 30, come tra 125 e 134, in inizio dovrebbe essere inserito 125 e a fine dovrebbe essere inserito 134

praticamente inizio e fine dovrebbero essere così composti:

inizio: [1; 60; 125; 255]
fine: [1; 60; 134; 255]

non so come fare... chi mi suggerisce qualcosa???

[gugoXX]

Se i valori contigui invece che 2 fossero 3,4,5 o piu'?

[cyberwolf4ever]

allora ad inizio andrebbe quello più basso e a fine quello più alto perdendo i valori di mezzo

[MarcoGG]

Originariamente inviato da cyberwolf4ever

...
quando lo scarto tra 2 elementi è maggiore di 30, per esempio 1 e 60, al primo posto utile dei 2 array, l'algoritmo dovrebbe inserire sia in inizio che in fine lo stesso valore... nel caso in cui invece, la differenza è inferiore a 30, come tra 125 e 134, in inizio dovrebbe essere inserito 125 e a fine dovrebbe essere inserito 134

praticamente inizio e fine dovrebbero essere così composti:

inizio: [1; 60; 125; 255]
fine: [1; 60; 134; 255]

Secondo me è poco chiaro qui : anzitutto il confronto tra i valori nell'array di partenza va fatto con tutte le combinazioni possibili o solo, scorrendo l'array, tra l'elemento N-esimo e il suo precedente ( ossia (N-1)-esimo ) ?

Inoltre nel caso in cui lo scarto tra 2 elementi è maggiore di 30, QUALE valore del confronto metti in entrambe le liste inizio e fine ? Il primo o il secondo ?

[gugoXX]

Poiche' non e' chiarissimo, propongo un approccio TDD.
Scrivi 5-6 casi diversi tra loro che coprano possibilmente tutte le casistiche che ti vengono in mente e il relativo risultato desiderato.

[cyberwolf4ever]

Originariamente inviato da gugoXX

Poiche' non e' chiarissimo, propongo un approccio TDD.
Scrivi 5-6 casi diversi tra loro che coprano possibilmente tutte le casistiche che ti vengono in mente e il relativo risultato desiderato.

ecco alcuni esempi:

1) array: [25; 56; 68; 76; 127; 130]

la differenza tra 56 e 68 e tra 68 e 76 è inferiore a 30... lo stesso tra 127 e 130... in questo caso abbiamo questi 2 array come risultato:

inizio: [25; 56; 127]
fine: [25; 76; 130]


2) array: [45; 55; 400; 415]

risultato:

inizio: [45; 400]
fine: [55; 415]

3) array: [56; 78]

risultato:

inizio:[56]
fine: [78]

4) array: [87; 99; 115]

risultato:

inizio: [87]
fine: [115]

spero di essere stato chiaro...

Originariamente inviato da MarcoGG

(...) il confronto tra i valori nell'array di partenza va fatto con tutte le combinazioni possibili o solo, scorrendo l'array, tra l'elemento N-esimo e il suo precedente ( ossia (N-1)-esimo ) ?

Inoltre nel caso in cui lo scarto tra 2 elementi è maggiore di 30, QUALE valore del confronto metti in entrambe le liste inizio e fine ? Il primo o il secondo ?

secondo me l'ideale sarebbe partire dall'elemento n-simo e confrontarlo con l'elemento (n+1)esimo e non il contrario.

nel caso in cui lo scarto sia maggiore di 30, il valore più piccolo dei 2 va inserito sia in inizio che in fine

[MarcoGG]

Originariamente inviato da cyberwolf4ever

1) array: [25; 56; 68; 76; 127; 130]

la differenza tra 56 e 68 e tra 68 e 76 è inferiore a 30... lo stesso tra 127 e 130... in questo caso abbiamo questi 2 array come risultato:

inizio: [25; 56; 127]
fine: [25; 76; 130]
...
secondo me l'ideale sarebbe partire dall'elemento n-simo e confrontarlo con l'elemento (n+1)esimo e non il contrario.

nel caso in cui lo scarto sia maggiore di 30, il valore più piccolo dei 2 va inserito sia in inizio che in fine

Allora c'è qualcosa che non va, oppure hai omesso qualche dettaglio :
se devo confrontare a coppie [n+1]-[n], su 6 numeri [25; 56; 68; 76; 127; 130] i confronti saranno :
56-25
68-56
76-68
127-76
130-127

5 confronti generano 5 numeri, perciò è impossibile che le due list in uscita siano quelle che hai postato. A meno che tu non abbia dimenticato di aggiungere che, comunque vada, le list non devono contenere doppioni.

[cyberwolf4ever]

Originariamente inviato da MarcoGG

Allora c'è qualcosa che non va, oppure hai omesso qualche dettaglio :
se devo confrontare a coppie [n+1]-[n], su 6 numeri [25; 56; 68; 76; 127; 130] i confronti saranno :
56-25
68-56
76-68
127-76
130-127

5 confronti generano 5 numeri, perciò è impossibile che le due list in uscita siano quelle che hai postato. A meno che tu non abbia dimenticato di aggiungere che, comunque vada, le list non devono contenere doppioni.

si, hai ragione scusami

[MarcoGG]

Stando agli esempi che hai postato, i primi 3 lasciano decisamente pensare che il confronto vada fatto tra l'elemento [n+2] ed [n], e NON [n+1] ed [n].

In tal caso :

            int[] arrayIniziale = new int[6] { 25, 56, 68, 76, 127, 130 };
            List<int> inizio = new List<int>();
            List<int> fine = new List<int>();

            int primoValore;
            int secondoValore;
            int scarto = 30;

            for (int i = 1; i < arrayIniziale.Length; i+=2)
            {
                primoValore = arrayIniziale[i - 1];
                secondoValore = arrayIniziale[i];

                if (secondoValore - primoValore >= scarto)
                {
                    inizio.Add(primoValore);
                    fine.Add(primoValore);
                }
                else
                {
                    inizio.Add(primoValore);
                    fine.Add(secondoValore);
                }
            }

            //Controllo
            foreach (int num in inizio)
            {
                MessageBox.Show("inizio : " + num.ToString());
            }
            foreach (int num in fine)
            {
                MessageBox.Show("fine : " + num.ToString());
            }

Rimane fuori l'ultimo esempio. Se i numeri nell'array sono dispari, nell'ipotesi di un confronto [n+2]-[n], ovviamente l'ultimo numero rimane spaiato, perciò le list in uscita non possono essere quelle che hai postato tu.
Intanto prova il mio codice, ma ho come la sensazione che tu non abbia ben chiaro COSA vuoi fare...

[cyberwolf4ever]

FORSE così ho risolto...

        private void inizio_fine(List<int> arr)
        {
            inizio = new List<int>();
            fine = new List<int>();
            int ind = 0;
            foreach (int num in arr)
            {
                if (ind == 0)
                {
                    inizio.Add(num);
                    fine.Add(num);
                }
                else
                {
                    int fin = fine[fine.Count - 1];
                    if ((num - fin) <= (fps * 2))
                    {
                        fine.Remove(fin);
                        fine.Add(num);
                    }
                    else
                    {
                        inizio.Add(num);
                        fine.Add(num);
                    }
                }
                ind++;
            }

        }

ditemi che ne pensate...