Un po 'di magia bool


20

Sfida

Dato il seguente metodo C #:

private static bool Test(bool a, bool b)
{
    if (a && b) return false;
    if (a) if (b) return true;
    return false;
}

Fornire i valori ae in bmodo che truevenga restituito.

Condizioni vincenti

La prima voce che può fornire gli argomenti corretti per fare in modo che il metodo dato valuti le truevincite.


4
Benvenuti in PPCG! Tutte le sfide qui richiedono un criterio obiettivo vincente in modo tale che un vincitore possa essere scelto se ci sono più proposte. Sembra che qui potrebbe esserci un'unica soluzione, quindi questa sfida potrebbe non essere adatta a PPCG. Per le sfide future, lasciatemi raccomandare la sandbox in cui è possibile ricevere feedback prima che la sfida diventi attiva.
Martin Ender,

2
La meta discussione è divisa sul fatto che i puzzle di programmazione senza criteri di vincita aggiuntivi siano in tema , con risposte contrastanti che vengono annullate. Preferirei tenere aperte le domande quando è instabile, quindi voterò per riaprire. Se hai delle opinioni, per favore, contribuiscile alla discussione.
xnor

2
@DenkerAffe Non credo che nessuna delle quattro ovvie combinazioni di parametri funzioni.
Martin Ender,

3
supponendo che ci sia una risposta valida, questa è un'ottima domanda, indipendentemente dal fatto che si adatti a ciò che normalmente consideriamo sull'argomento. + 1. Penso che uno dei motivi per cui normalmente non consideriamo domande come questa sull'argomento è che ogni altra domanda che ho visto in questo modo è stata fatta da un principiante e la risposta è stata palesemente ovvia.
Level River St,

5
@Widi Ecco perché "la prima soluzione valida" potrebbe non essere la migliore idea. Potresti ottenere una soluzione poco interessante ma funzionante che fa casini con alcuni interni tramite la riflessione e quindi non c'è incentivo per nessuno a cercare una soluzione più interessante senza riflessione.
Martin Ender,

Risposte:


20
static void Main(string[] args)
{
    bool a, b;
    unsafe
    {
        int* pa = (int*)&a;
        int* pb = (int*)&b;
        *pa = 1;
        *pb = 2;
    }

        Console.Write(Test(a, b));
}

Questo stampa Trueper me con l'implementazione di C # fornita con Visual Studio 2015. In realtà non conosco alcun C #, ma ho pensato di provare a scrivere del codice C e vedere se funzionava. Speravo che il compilatore potesse supporre che True sia sempre rappresentato come 1 e utilizzi un AND bit per bit. In modalità Debug, questo è effettivamente il caso (ha funzionato anche con Release). Usa un AND bit per bit per la prima condizione e due confronti a zero per la seconda:

            if (a && b) return false;
002C2E92  movzx       eax,byte ptr [ebp-3Ch]  
002C2E96  movzx       edx,byte ptr [ebp-40h]  
002C2E9A  and         eax,edx  
002C2E9C  and         eax,0FFh  
002C2EA1  mov         dword ptr [ebp-44h],eax  
002C2EA4  cmp         dword ptr [ebp-44h],0  
002C2EA8  je          002C2EB2  
002C2EAA  xor         edx,edx  
002C2EAC  mov         dword ptr [ebp-48h],edx  
002C2EAF  nop  
002C2EB0  jmp         002C2EE4  
            if (a) if (b) return true;
002C2EB2  movzx       eax,byte ptr [ebp-3Ch]  
002C2EB6  mov         dword ptr [ebp-4Ch],eax  
002C2EB9  cmp         dword ptr [ebp-4Ch],0  
002C2EBD  je          002C2EDC  
002C2EBF  movzx       eax,byte ptr [ebp-40h]  
002C2EC3  mov         dword ptr [ebp-50h],eax  
002C2EC6  cmp         dword ptr [ebp-50h],0  
002C2ECA  je          002C2EDC  
002C2ECC  mov         eax,1  
002C2ED1  and         eax,0FFh  
002C2ED6  mov         dword ptr [ebp-48h],eax  
002C2ED9  nop  
002C2EDA  jmp         002C2EE4  
            return false;
002C2EDC  xor         edx,edx  
002C2EDE  mov         dword ptr [ebp-48h],edx  
002C2EE1  nop  
002C2EE2  jmp         002C2EE4  
        }
002C2EE4  mov         eax,dword ptr [ebp-48h]  
002C2EE7  lea         esp,[ebp-0Ch]  
002C2EEA  pop         ebx  
002C2EEB  pop         esi  
002C2EEC  pop         edi  
002C2EED  pop         ebp  
002C2EEE  ret  

Sorprendente! Ero assolutamente sicuro che non si potesse fare
edc65,

Ho provato la stessa cosa ma non sembra funzionare in Mono su Linux.
jimmy23013,

Ciò dipende non dal compilatore C # (attualmente Roslyn di MS) ma piuttosto dal compilatore JIT (attualmente RyuJIT di MS). Sebbene l'IL prodotto dal compilatore C # possa anche influire su ciò che fa JIT.
Bob,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.