[C#] Ordinamento stringhe

[phosphore]

Ciao a tutti!
Oggi ho un'altro problema per voi
Sto provando a creare una piccola applicazione in c# in cui è presente una textbox in cui inserire la stringa e 2 radiobutton in cui si può selezionare se:

1) se è selezionato il RadioButton Pari si mettono prima i caratteri di posizione pari e poi quelli di posizione dispari
2) se è selezionato Dispari si mettono prima i caratteri di posizione dispari e poi i pari.

Es. Se il messaggio è "abcdefg" il programma deve restituire "acegbdf".
L'algoritmo può essere una cosa del genere?

string messaggio = Convert.ToString(textBox1.Text);
string definitivo2;
string[] definitivo = messaggio.Split();

if (radioButton1.Checked == true)
            {
                for (int i = 1; i < definitivo.Length; i++)
                {
                    char a;
                    
                    if (i % 2 == 0)
                    {
                        a = Convert.ToChar(definitivo[i - 1]);
                        definitivo[i - 1] = definitivo[i];
                        definitivo[i] = Convert.ToString(a);
                    }
                }
                
                for (int i = 0; i < definitivo.Length; i++)
                {
                    definitivo2 = definitivo2 + definitivo[i];
                }
                textBox2.Text = definitivo2;

            }

Il problema è che mi restituisce la stringa iniziale e non me la converte.
A qualcuno viene un'idea?

[phosphore]

E' forse lo split che da problemi? E' perchè l'ho richiamato con solo
string[] definitivo = messaggio.Split();
e non gli ho dato un separatore da seguire? E allora come faccio ad avere una array contenente tutti i caratteri di una stringa?

[phosphore]

Ho fatto una cosa del genere:

            string[] definitivo = new string[messaggio.Length];
            for (int i = 0; i < messaggio.Length; i++)
            {
                definitivo[i] = Convert.ToString(messaggio[i]);
            }

e ora l'output dando "abcdefg" è "acbedgf".

[U235]

Ciao,
buttato giù al volo... non so se è quello che volevi e non so se sia il modo migliore, ma è il primo che mi è venuto :

string mess = "abcdefg";
bool dispari= true;
int i = 0;
string orderString = string.Join(string.Empty, mess.ToArray().GroupBy(p => (i++ % 2) == 0).OrderBy(o=>dispari?o.First():o.Last()).SelectMany(p => p));

edit : ho messo dispari al posto di pari (corretto )

[torn24]

Secondo me dovresti usare array di char al posto delle stringhe.


char[] definitivo = new char[200];
definitivo = textBox1.Text.ToCharArray();


occhio che quando vuoi chiudere un array di char , devi inserire il terminatore

definitivo[100]='\0'; //fine array char

[ESSE-EFFE]

Un'idea buttata giù al volo...

        private string Ordina(string In)
        {
            StringBuilder Out = new StringBuilder(In.Length);
            for (int i = 0; i < 2; i++)
            {
                for (int j = i; j < In.Length; j += 2)
                {
                    Out.Append(In[j]);
                }
            }
            return (Out.ToString());
        }

[U235]

Originariamente inviato da ESSE-EFFE
Un'idea buttata giù al volo...

        private string Ordina(string In)
        {
            StringBuilder Out = new StringBuilder(In.Length);
            for (int i = 0; i < 2; i++)
            {
                for (int j = i; j < In.Length; j += 2)
                {
                    Out.Append(In[j]);
                }
            }
            return (Out.ToString());
        }

Ciao
stavo ragionando un pò sulla tua soluzione, ottima , ma per invertire l'ordine?

[ESSE-EFFE]

Originariamente inviato da U235
Ciao
stavo ragionando un pò sulla tua soluzione, ottima

Non è ottimizzata, ma mi sembrava il sistema più semplice.

Originariamente inviato da U235
, ma per invertire l'ordine?

Basta "allungare" un po' una delle righe (di codice). Ho già testato anche la versione completa, ma non volevo togliere all'OP il gusto di completarla da sè. Casomai, se non emerge, più avanti la posto.

[U235]

Originariamente inviato da ESSE-EFFE
Non è ottimizzata, ma mi sembrava il sistema più semplice.


Basta "allungare" un po' una delle righe (di codice). Ho già testato anche la versione completa, ma non volevo togliere all'OP il gusto di completarla da sè. Casomai, se non emerge, più avanti la posto.

se ti va postamela in privato, ma magari se la condividi con tutti è meglio.

[U235]

Comunque io una soluzione per il tuo algoritmo l'ho pure trovata, ma ovviamente preferisco vedere la tua, più che altro perchè vorrei vedere la differenza a livello di pulizia di codice.
mi spiego meglio :
con questa soluzione

string mess = "abcdefg";
bool dispari= true;
int i = 0;
string order = string.Concat(mess.GroupBy(p => (i++ % 2) == 0)
      .OrderBy(o => dispari ? o.First() : o.Last())
      .SelectMany(p => p));

il codice è un pò meno e un pò più pulito (poi anche questo è opinabile...), ma a livello di prestazioni perde (e questo è un dato di fatto), se lo guardiamo in percentuale la differenza di prestazioni è tantissima, ma a livello numerico si tratta di 10 ms circa contro i 4 ms circa del tuo (senza algoritmo di inversione, ma non cambierebbe comunque di molto), e questo cambia di pochissimo anche aggiungendo una stringa molto lunga (file di testo abbastanza grosso), quindi comunque si tratta di pochi ms...

a questo punto io mi sono domandato : ma visto che la differenza di pulizia e poca così come la differenza di prestazioni, perchè nella maggior parte delle aziende in cui ho lavorato (alcune anche "grosse") pretendono linq e se fai qualche ciclo storcono il naso dicendo che è poco leggibile? e magari poi ti dicono pure che devi spremere più velocità possibile

secondo voi forumisti, un cicletto ogni tanto non ci sta pure bene ? (vedi questo caso...)