Scambio di due variabili senza l’utilizzo di una variabile temporanea

Mi piacerebbe essere in grado di scambiare due variabili senza l’uso di una variabile temporanea in C#. Questo può essere fatto?

decimal startAngle = Convert.ToDecimal(159.9);
decimal stopAngle = Convert.ToDecimal(355.87);

//Swap each:
//  startAngle becomes: 355.87
//  stopAngle becomes: 159.9
InformationsquelleAutor Sreedhar | 2009-04-29

 

28 Replies
  1. 111

    Prima di tutto, scambio, senza una variabile temporanea in un linguaggio come C# è un pessima idea.

    Ma per il bene di risposta potete utilizzare questo codice:

    startAngle = startAngle + stopAngle;
    stopAngle = startAngle - stopAngle;
    startAngle = startAngle - stopAngle;

    Problemi possono tuttavia verificarsi con arrotondamento se i due numeri differiscono di molto. Questo è a causa della natura dei numeri a virgola mobile.

    Se si desidera nascondere la variabile temporanea, è possibile utilizzare un metodo di utilità:

    public static class Foo {
    
        public static void Swap<T> (ref T lhs, ref T rhs) {
            T temp = lhs;
            lhs = rhs;
            rhs = temp;
        }
    }
    • Va bene per i numeri interi o in virgola fissa numeri. Con numeri in virgola mobile vi ritroverete con minuti di errori di arrotondamento. Essi possono o non possono essere sufficientemente grande per materia, dipende da come si sta utilizzando i numeri.
    • Finchè non incorrere in problemi di overflow, che funziona bene
    • Belenky: infatti, ma non vedo un’altra soluzione, ad eccezione di un valore temporaneo. Quindi penso che l’unica “buona” modo per risolvere questo problema. (Mi dispiace per il mio inglese, se ho fatto errori)
    • Il solo buona modo per risolvere questo problema è quello di utilizzare una variabile temp. “Intelligente” codice come questo (e, da “intelligente”, intendo dire “stupido”) è molto meno leggibile e ovvio che la temp variabile soluzione. Se non ho visto il codice di questo da uno dei miei servitori avrebbero dovuto essere soggette a sanzioni e inviato di nuovo a destra. Io non avendo un andare a voi in particolare, @CommuSoft (dato che non hai risposto alla domanda, ma la domanda stessa era spazzatura.
    • Che funziona per tutte le ragioni sbagliate immaginabile…
    • Lenar: Beh, in lingue con puntatore manipolazione che si potrebbe usare lo stesso trucco per scambiare i puntatori. In C# è possibile fare questo in un ambiente a rischio. 😀 Ma comunque ammetto scambio di oggetti,ect. senza una terza variabile è una cattiva idea (in reazione a questo. __curiosa_geek). Ma la questione ha detto esplicitamente di farlo senza una variabile in più.
    • Questa tecnica è più dispendioso rispetto all’utilizzo di una variabile temporanea.
    • Sì, lo so, ma la domanda ha chiesto se era possibile farlo senza una variabile temporanea. Se si compila il codice con una variabile temporanea, probabilmente non sarà nemmeno bisogno di memoria aggiuntiva in quanto la variabile temporanea vorresti solo essere memorizzato in un registro del processore. Ma suppongo che la domanda era compiti a casa o qualcosa di equivalente.
    • Non mi piace la frase “scambio senza una variabile temp è una pessima idea”. Molte lingue il supporto scambio di variabili in modo chiaro, senza l’errore-incline 3-linea shuffle, quindi è logico chiedere se C#. Python: a, b = b, a, C++: std::swap(a, b).
    • Certo, alcune CPU hanno anche istruzioni specifiche, o una macro per farlo. Ma matematici trucchi per processo non è come dovrebbe essere fatto. Esso è passibile di errore, è difficile da capire. E per Python, ciò che devi fare è creare una tupla come una terza variabile. Per C++'s swap è semplicemente nascondere il terzo valore nel metodo (o viene elaborata dalla CPU direttamente). Nel caso, tuttavia, non è disponibile, non utilizzando tale variabile è in cerca di guai.

  2. 213

    Il diritto modo di scambiare due variabili:

    decimal tempDecimal = startAngle;
    startAngle = stopAngle;
    stopAngle = tempDecimal;

    In altre parole, utilizzare una variabile temporanea.

    C’è l’hanno. Senza trucchi intelligenti, non manutentori del codice maledizione per i decenni a venire, non voci di Il Quotidiano WTF, e non spendere troppo tempo a cercare di capire perché è necessario farlo in una sola operazione, comunque, dato, al livello più basso, anche il più complesso funzionalità del linguaggio, è una serie di semplici operazioni.

    Solo una semplice, leggibile, facile da capire, t = a; a = b; b = t; soluzione.

    A mio parere, gli sviluppatori che cercano di usare i trucchi, per esempio, di “scambio di variabili senza l’utilizzo di un temp” o “Duff dispositivo” sono solo cercando di mostrare quanto sono intelligenti (e fallendo miseramente).

    Mi paragonano a chi ha letto i libri di intellettuali per il solo scopo di apparire più interessante in parti (invece di espandere i vostri orizzonti).

    Soluzioni in cui è possibile aggiungere e sottrarre, o XOR-quelli di base, sono meno leggibili e molto probabilmente più lento di un semplice “variabile temp” soluzione (arithmetic/boolean-ops invece di pianura si muove a un livello di montaggio).

    Fare te stesso e gli altri, un servizio di scrittura di qualità buona lettura del codice.

    Che il mio sfogo. Grazie per l’ascolto 🙂

    Come un a parte, sono abbastanza consapevole che questo non risponde alla domanda specifica (e io ti scuso per questo) ma c’è un sacco di precedenti sul MODO in cui le persone ci hanno chiesto come fare qualcosa, e la risposta corretta è “non farlo”.

    • +1; e per più motivi: con il +/- (ecc) trucchi che stanno facendo inutili aritmetica. Con numeri interi, che può essere solo accettabile in un push (la arrotondamento/overflow non sono problemi, e il costo della CPU è quasi nulla), ma con cifre decimali, aggiungere e sottrarre non sono banali operazioni. Non è in grado di utilizzare la FPU, in quanto non sono float/double. Quindi, utilizzare una variabile temp già!!!
    • naturalmente questo è il modo migliore, ma è stato esplicito richiesto senza variabile temp
    • +1 sono d’accordo con te. Quando si inizia a complicare le cose semplici si finisce con tutti i tipi di problemi da risolvere nei prossimi anni…
    • Forse c’è un vero motivo per non usare la variabile temp. Se le due variabili sono estremamente grande, non si vuole creare uno nuovo quindi avendo 3 estremamente grande in variabili ancora non per molto tempo.
    • Per quanto ne so, il problema è risolto era come srotolare un ciclo in C, consentendo un numero non intero di moltiplicatore sul primo o sull’ultimo ciclo. Si può fare facilmente senza ricorrere all’utilizzo di Duff Dispositivo, e in un altro modo più leggibile. Se si pensa che è stato risolto un problema diverso che non può essere risolto più “readably”, sono aperto a essere convinto. In ogni caso, anche se è stato risolto un problema a un certo punto, in passato, è quasi mai necessario oggi, anche su tutti, ma il puniest sistemi embedded.
    • Vale la pena di aggiungere che il destra modo C# è quello di utilizzare una variabile temp, ma non è un fatto universale. Il idiomatiche modo in Python sarebbe a, b = b ,a
    • in Python è creare virtualmente un qualche tipo di tupla. Questo è il terzo valore.
    • gli oggetti temporanei non sono le stesse variabili temporanee. giusto o sbagliato, che extra temp inquina leggibilità, mentre il divinatori strada è pulita.
    • beh in realtà una variabile temporanea non esiste mai. Si richiede liveness analisi per determinare quando una variabile è vivo e che è la fase del compilatore dove si prende gli oggetti temporanei in considerazione. A a livello di sintassi, variabili inizia a vivere in dichiarazione e muore alla fine del metodo. Ci sono solo locali e mondiale variabili…
    • variabile” non è un costrutto del linguaggio, non c’è bisogno per la torsione delle parole. Questo è circa la concisione e la leggibilità, non sull’output del compilatore o VM comportamento.
    • “Non farlo” le risposte sono uno dei virus di COSÌ. La risposta presuppone contesto e non è produttivo. Il metodo di creazione di una variabile temporanea è molto meno leggibile tupla a base di approcci che permettono una semplice linea di evidente e leggibile swap che è migliore e più pulita in ogni modo di questi temp variabile approcci. Egli aveva chiesto a un po ‘ più tardi, quando la funzione esisteva in C# forse avrebbe già ottenuto produttivi risposta piuttosto che queste inutili sproloqui che esistono solo per rendere la persona affermando di loro si sente superiore.
    • Jeffrey, ogni risposta a una domanda presuppone che alcuni contesto, che è inevitabile. Ma “non farlo” risposte a volte sono le migliori. Se si utilizza un indifferenziati variabile lunghezza di registrazione di file di testo come un multi-gigabyte database, è dovrebbe va detto che è una cattiva idea. E, prima di iniziare l’assegnazione di motivi per la gente, si potrebbe voler almeno considerare (la possibilità che alcune persone non per saperne di più di altri su certi argomenti. So di considerare che, per essere così perché ho chiesto domande qui su aree sono carenti. Che è, dopo tutto, ciò che rende i siti come questo utile. …
    • … Sarò felice di ammettere che Python tupla di assegnazione è di gran lunga il modo più leggibile, ma C# non sono che quando la risposta è stato pubblicato. In ogni caso, che la leggibilità non non riporto al xor o add/sub metodi – sono molto meno leggibile di un temp-var soluzione.

  3. 77

    C# 7 ha introdotto tuple che consente lo scambio di due variabili senza temporanea:

    int a = 10;
    int b = 2;
    (a, b) = (b, a);

    Questo assegna b per a e a per b.

    • È solo un peccato che questa funzione non esisteva in precedenza, dove avrebbe già potenzialmente imparato un nuovo e potente costrutto del linguaggio che hai dato più strumenti nella cassetta degli attrezzi a rompere i problemi aperti con, invece di tutte le inutili sproloqui di cui sopra.
  4. 72

    Sì, uso questo codice:

    stopAngle = Convert.ToDecimal(159.9);
    startAngle = Convert.ToDecimal(355.87);

    Il problema è più difficile per valori arbitrari. 🙂

  5. 43
    int a = 4, b = 6;
    a ^= b ^= a ^= b;

    Funziona per tutti i tipi tra cui stringhe e carri allegorici.

    • Spero che il XOR swap sarà dimenticato un giorno.
    • XOR swap è vicino l’apice della nerdiness. Ho avuto nirvana per un paio di giorni dopo di apprendimento a scuola.
    • Questo non sembra funzionare a tutti stackoverflow.com/questions/5577140/…
    • Almeno aggiungi un commento così è comprensibile anche per i non”binario ninja”
    • Questo è C#. Il codice non lo swap, come @zespri dice. Per la tua ultima frase: In C# non è possibile utilizzare l’operatore ^= con string o float, in modo da non compilare con loro.
    • Credo che questo per essere l’apice di nedriness. Ragazzo assembla un programma di lavoro in Pokemon da scambiare oggetti in inventario.
    • Se mai volare in US govt. prodotto jet da combattimento, o di avere un pacemaker, ecc…. Mi auguro sul serio che io non muoiono a causa di un stackoverflow causato da qualche programmatore che “spera che XOR swap sarebbe dimenticato qualche giorno”

  6. 19

    BenAlabaster ha mostrato un modo pratico di fare una variabile interruttore, ma il try-catch clausola non è necessario. Questo codice è abbastanza.

    static void Swap<T>(ref T x, ref T y)
    {
         T t = y;
         y = x;
         x = t;
    }

    L’uso è lo stesso come ha dimostrato:

    float startAngle = 159.9F
    float stopAngle = 355.87F
    Swap(ref startAngle, ref stopAngle);

    Si potrebbe anche usare un metodo di estensione:

    static class SwapExtension
    {
        public static T Swap<T>(this T x, ref T y)
        {
            T t = y;
            y = x;
            return t;
        }
    }

    Usarlo come questo:

    float startAngle = 159.9F;
    float stopAngle = 355.87F;
    startAngle = startAngle.Swap(ref stopAngle);

    In entrambi i modi utilizza una variabile temporanea nel metodo, ma non è necessario che la variabile temporanea in cui effettuare lo scambio.

    • Questo utilizza una variabile temp (t)….
    • Sì, ma solo nel metodo, non dove fare l’interruttore.
    • Utilizzando un’astrazione è un buon modo di risolvere il problema. Esso fornisce una soluzione generale al problema comune e rende la chiamata di codice più facile da leggere. Naturalmente, si utilizza un qualche extra byte di memoria e un paio di cicli di clock del processore, ma a meno che non si sta chiamando questo codice di milioni di volte, non si noterà alcuna differenza.
    • Spero che se si chiama un milione di volte, il JIT lo ottimizzare.
    • Quindi la domanda è, perché non era questa utile funzione inclusa nel .Libreria di rete? È il primo esempio presentato la documentazione per Metodi Generici.
  7. 15

    Un binario XOR swap, con un esempio dettagliato:

    XOR tabella di verità:

    a b a^b
    0 0  0
    0 1  1
    1 0  1
    1 1  0

    Ingresso:

    a = 4;
    b = 6;

    Passo 1: a = a ^ b

    a  : 0100
    b  : 0110
    a^b: 0010 = 2 = a

    Passo 2: b = a ^ b

    a  : 0010
    b  : 0110
    a^b: 0100 = 4 = b

    Passo 3: a = a ^ b

    a  : 0010
    b  : 0100
    a^b: 0110 = 6 = a

    Di uscita:

    a = 6;
    b = 4;
  8. 12

    Per il bene dei futuri studenti, e l’umanità, mi invia questa correzione per le risposte attualmente selezionato.

    Se si desidera evitare di utilizzare le variabili temp, ci sono solo due opzioni ragionevoli che prendere la prima a prestazioni e quindi la leggibilità in considerazione.

    • Utilizzare una variabile temp in un generico Swap metodo. (Migliori prestazioni in assoluto, accanto a inline variabile temp)
    • Utilizzare Intrecciata.Exchange. (5.9 volte più lento sulla mia macchina, ma questa è l’unica opzione se più thread di scambio di queste variabili contemporaneamente.)

    Cose che si dovrebbe mai fare:

    • Non usare mai in virgola mobile aritmetica. (lento, arrotondamento e gli errori di overflow, difficile da capire)
    • Non utilizzare mai non primitive aritmetica. (lento, errori di overflow, difficile da capire) Decimale non è una CPU primitiva e risultati molto più codice che ti rendi conto.
    • Non utilizzare mai aritmetica periodo. O un po ‘ hack. (lento, difficile da capire) Che il compilatore del lavoro. È possibile ottimizzare per molte piattaforme differenti.

    Perché tutti amano i numeri duri, ecco un programma che consente di confrontare le vostre opzioni. Eseguirlo in modalità di rilascio da esterno di Visual Studio in modo che Swap è inline. Risultati sulla mia macchina (Windows 7 64-bit i5-3470):

    Inline:      00:00:00.7351931
    Call:        00:00:00.7483503
    Interlocked: 00:00:04.4076651

    Codice:

    class Program
    {
        static void Swap<T>(ref T obj1, ref T obj2)
        {
            var temp = obj1;
            obj1 = obj2;
            obj2 = temp;
        }
    
        static void Main(string[] args)
        {
            var a = new object();
            var b = new object();
    
            var s = new Stopwatch();
    
            Swap(ref a, ref b); //JIT the swap method outside the stopwatch
    
            s.Restart();
            for (var i = 0; i < 500000000; i++)
            {
                var temp = a;
                a = b;
                b = temp;
            }
            s.Stop();
            Console.WriteLine("Inline temp: " + s.Elapsed);
    
    
            s.Restart();
            for (var i = 0; i < 500000000; i++)
            {
                Swap(ref a, ref b);
            }
            s.Stop();
            Console.WriteLine("Call:        " + s.Elapsed);
    
            s.Restart();
            for (var i = 0; i < 500000000; i++)
            {
                b = Interlocked.Exchange(ref a, b);
            }
            s.Stop();
            Console.WriteLine("Interlocked: " + s.Elapsed);
    
            Console.ReadKey();
        }
    }
    • Po ‘ hack non sono lenta a tutti. Per esempio per caricare 0 in un registro, un compilatore xor la variabile con se stessa, perché l’istruzione è più breve. In alcune rare occasioni, usando meno variabili, si evita di registrare la fuoriuscita. È il compilatori di lavoro, ma è un peccato che non vi è alcun supporto per la lingua per fare questo in modo efficiente.
    • Hai ragione. Nei casi In cui questo è un hotspot e velocità questioni che male, si sta andando ad avere bisogno di andare non gestito. Po ‘ hack spesso ritorno di fiamma in lingue gestite. Che davvero la responsabilità di jitter.
  9. 11

    Non in C#. Nel codice nativo si potrebbe essere in grado di utilizzare il triple-XOR swap trucco, ma non in un alto livello di type-safe lingua. (Comunque, ho sentito dire che il XOR trucco, in realtà finisce per essere più lento rispetto all’utilizzo di una variabile temporanea in molti comuni architetture di CPU.)

    Si dovrebbe usare una variabile temporanea. Non c’è alcun motivo non è possibile utilizzare uno; non è che c’è un offerta limitata.

    • La maggior parte dei tipi di XOR cosa funziona per rientrare in un registro in modo che il compilatore non deve allocare lo spazio dello stack per comunque.
    • Vero, ma è più complesso. Raramente si ha bisogno di scambiare i valori di livello assembler. Lo scambio può essere fatto come un effetto collaterale di altre aritmetica. La maggior parte del tempo lo swap è solo richiesto di esprimere le cose in un linguaggio di alto livello. Dopo la compilazione di swap non c’è più e quindi i costi di nessun momento a tutti 🙂
    • Se la memoria è in approvvigionamento corto, come ad esempio su un dispositivo embedded, quindi le variabili temp sono in approvvigionamento corto, a volte.
    • ma sarebbe meglio se C# offerto un modo per scambiare due variabili. Quindi questo può essere implementato con o senza la variabile temp. Facendo esplicitamente, il codice diventa illeggibile ed è difficile da mantenere.
  10. 7

    <deprecato>

    Si può fare in 3 linee con la matematica di base – nel mio esempio ho usato la moltiplicazione, ma la semplice aggiunta funzionerebbe anche.

    float startAngle = 159.9F;
    float stopAngle = 355.87F;
    
    startAngle = startAngle * stopAngle;
    stopAngle = startAngle / stopAngle;
    startAngle = startAngle / stopAngle;

    Edit: Come indicato nei commenti, questo non avrebbe funzionato se y = 0 come avrebbe generato un errore di divisione per zero che non avevo considerato. Così il +/- soluzione in alternativa presentato sarebbe il modo migliore per andare.

    </obsoleto>


    Per mantenere il mio codice immediatamente comprensibile, mi piacerebbe essere più propensi a fare qualcosa di simile a questo. [Pensa sempre al povero ragazzo che cosa hanno intenzione di mantenere il vostro codice]:

    static bool Swap<T>(ref T x, ref T y)
    {
        try
        {
            T t = y;
            y = x;
            x = t;
            return true;
        }
        catch
        {
            return false;
        }
    }

    E poi si può farlo in una sola riga di codice:

    float startAngle = 159.9F
    float stopAngle = 355.87F
    Swap<float>(ref startAngle, ref stopAngle);

    O…

    MyObject obj1 = new MyObject("object1");
    MyObject obj2 = new MyObject("object2");
    Swap<MyObject>(ref obj1, ref obj2);

    Fatto come una cena…ora si può passare in qualsiasi tipo di oggetto e passare in giro…

    • po ‘ uguale alla mia soluzione, ma si noti che la moltiplicazione e la divisione operazione costi un sacco di CPU. E la parte superiore e inferiore limiti di un galleggiante, sono più facili da raggiungere con la moltiplicazione.
    • Cosa vuoi dire con “Decimale da non consentire decimali? Che suoni confusi come il tipo decimal non rappresentano numeri reali con alta precisione (decimale d = 9.1 m; è perfettamente valido in C#).
    • e cosa succede se una delle variabili è pari a zero (o entrambi), la seconda divisione sarà causa di un errore di divisione per zero). E la funzione creata da poter meglio return false per avvertire l’utente che l’operazione di swap non è stato completato.
    • Io trovo corretto… devo aver perso quella classe, avevo cercato di assegnare Decimale n = 9.1; e solo mi dà un errore del compilatore. Perso il M alla fine 😛 Risposta modificati di conseguenza.
    • Punto preso, non avevo considerato che. In questo caso, il +/- sarebbe sicuramente il modo migliore per andare.
    • Che cosa succede con il tuo metodo swap? Perché non restituire un valore booleano, il motivo è che bool sempre vero (se esiste)? Perché non ingoiare tutte le eccezioni (che potrebbe essere solo un ThreadAbortException in questo caso, io credo, dal momento che non allocare la memoria o ingrandire lo stack di chiamate)?
    • Semplice, fortemente tipizzato assegnazioni, che non prevedono matrice di varianza non potrà mai generare eccezioni. Le incongruenze di tipo saranno presi in fase di compilazione (questo è ciò che la tipizzazione forte è circa).

  11. 5

    Per completezza, qui è il binario di XOR swap:

    int x = 42;
    int y = 51236;
    x ^= y;
    y ^= x;
    x ^= y;

    Questo funziona per tutti atomica oggetti/riferimenti, in quanto si tratta direttamente con il byte, ma può richiedere un contesto unsafe a lavorare sui decimali oppure, se ti senti davvero contorto, puntatori. E può essere più lenta di una variabile temp in alcune circostanze.

  12. 5

    Con C# 7, è possibile utilizzare tupla decostruzione per ottenere il desiderato swap in una riga, ed è chiaro che cosa sta succedendo.

    decimal startAngle = Convert.ToDecimal(159.9);
    decimal stopAngle = Convert.ToDecimal(355.87);
    
    (startAngle, stopAngle) = (stopAngle, startAngle);
  13. 4

    Attenzione del vostro ambiente!

    Per esempio, questo non sembra funzionare in ECMAscript

    y ^= x ^= y ^= x;

    Ma questo non

    x ^= y ^= x; y ^= x;

    Il mio consiglio? Assumere il meno possibile.

    • Anche in c, se i puntatori sono coinvolti (e.g in funzione) *a ^= *b ^= *a ^= *b non funziona (variabile locale però funziona e.g c ^= d ^= c ^= d), ma *a ^= *b ^= *a; *b ^= *a; opere. La mia scelta quindi sarebbe da usare *a ^= *b; *b ^= *a; *a ^= *b; che funziona perfettamente.
    • Come è ECMAscript rilevante? La domanda è tagged C#.
  14. 3

    Il modo più semplice per scambiare 2 numeri in una sola riga:

    a=(a+b)-(b=a);

    ad esempio: a=1, b=2

    Passo 1: a=(1+2) – (b=1)

    Passo 2: a=3-1

    => a=2 e b=1


    Modo efficace è quello di utilizzare:

    Di Programmazione C: (x ^= y), (y ^= x), (x ^= y);

    Java: x = x ^ y ^ (y = x);

    Python: x, y = y, x

    Nota: Più comune di errore:
    //Swap utilizzando XOR bit a bit (Soluzione Sbagliata in C/C++)

    x ^= y ^= x ^= y; 

    Fonte: GeeksforGeek

    • proprio c++: std::swap(x, y);.
  15. 2

    Per tipi binari è possibile utilizzare questo funky trucco:

    a %= b %= a %= b;

    Fintanto che a e b non sono esattamente la stessa variabile (ad esempio alias per la stessa memoria) funziona.

    • vedi anche Jens Alfke risposta
  16. 2

    Spero che questo possa aiutare…

    using System;
    
    public class Program
    {
        public static void Main()
        {
            int a = 1234;
            int b = 4321;
    
            Console.WriteLine("Before: a {0} and b {1}", a, b);
    
            b = b - a;
            a = a + b;
            b = a - b;
    
            Console.WriteLine("After: a {0} and b {1}", a, b);
        }
    }
  17. 2

    possiamo farlo facendo un semplice trucco

    a = 20;
    b = 30;
    a = a+b; //add both the number now a has value 50
    b = a-b; //here we are extracting one number from the sum by sub
    a = a-b; //the number so obtained in above help us to fetch the alternate number from sum
    System.out.print("swapped numbers are a = "+ a+"b = "+ b);
  18. 2

    Con tuple

    decimal startAngle = Convert.ToDecimal(159.9);
    decimal stopAngle = Convert.ToDecimal(355.87);
    
    (startAngle, stopAngle) = (stopAngle, startAngle);
  19. 1

    Se vuoi scambiare 2 variabili di stringa:

    a = (a+b).Substring((b=a).Length);

    Un metodo helper di conseguenza:

    public static class Foo {
        public static void SwapString (ref string a, ref string b) {
           a = (a+b).Substring((b=a).Length);
        }
    }

    Utilizzo sarebbe quindi:

    string a="Test 1";
    string b="Test 2";
    Foo.SwapString(a, b);
  20. 0

    Qui un altro approccio in una riga:

    decimal a = 159.9m;
    decimal b = 355.87m;
    
    a = b + (b = a) - b;
  21. 0

    Qui è un po ‘ diverso processo di scambio di due variabili

    //process one
    a=b+a;
    b=a-b;
    a=a-b;
    printf("a= %d  b=  %d",a,b);
    
    //process two
    a=5;
    b=10;
    a=a+b-(b=a);
    printf("\na= %d  b=  %d",a,b);
    
    //process three
    a=5;
    b=10;
    a=a^b;
    b=a^b;
    a=b^a;
    printf("\na= %d  b=  %d",a,b);
    
    //process four
    a=5;
    b=10;
    a=b-~a-1;
    b=a+~b+1;
    a=a+~b+1;
    printf("\na= %d  b=  %d",a,b);
  22. -2
    var a = 15;
    var b = -214;
    a = b | !(b = a);

    Questo funziona alla grande.

    • Non lavoro se a=0
    • Come sarebbe??
  23. -4

    Molto semplice codice per lo scambio di due variabili:

    static void Main(string[] args)
    {
        Console.WriteLine("Prof.Owais ahmed");
        Console.WriteLine("Swapping two variables");
    
        Console.WriteLine("Enter your first number ");
        int x = Convert.ToInt32(Console.ReadLine());
    
        Console.WriteLine("Enter your first number ");
        int y = Convert.ToInt32(Console.ReadLine());
    
        Console.WriteLine("your vlaue of x is="+x+"\nyour value of y is="+y);
    
        int z = x;
        x = y;
        y = z;
    
        Console.WriteLine("after Swapping value of x is="+x+"/nyour value of y is="+y);
        Console.ReadLine();
    }
    • Abbastanza sicuro che z conta come una variabile temp qui.
    • se si sposta fuori della funzione e rendere statico Non sarà una temp più lol
  24. -4

    Si può provare il codice riportato di seguito. È molto più meglio dell’altro codice.

    a = a + b;
    b = a - b;
    a = a - b;
    • Questo è il esattamente lo stesso, come molte delle altre risposte. Alcuni dei quali sono stati aggiunti già 7 anni fa!

Lascia un commento