X maggiore di 3 con almeno 2 differenze tra X e Y

11

Sto cercando di giocare a golf con il C ++. È possibile ridurre questa condizione?

X > 3 & X - Y > 1

(A parte rimuovere gli spazi bianchi, ovviamente.)

Quindi, Xè almeno 4ma X >= Y + 2.

Xe Ysono numeri interi nell'intervallo [0,5].

Ho provato a trovare una formula bit per bit ma non ci sono riuscito.

code-golf  number  tips  c++  code-golf  popularity-contest  obfuscation  code-golf  c  code-golf  board-game  hexagonal-grid  code-golf  game  grid  code-golf  number  permutations  popularity-contest  math  graphical-output  number-theory  king-of-the-hill  code-challenge  compression  code-challenge  fastest-code  code-golf  math  ascii-art  animation  code-golf  popularity-contest  generation  counting  fastest-code  fastest-code  popularity-contest  image-processing  king-of-the-hill  code-golf  conversion  binary-tree  code-golf  math  number  rational-numbers  division  code-golf  restricted-source  hashing  atomic-code-golf  logic-gates  code-golf  function  code-challenge  puzzle-solver  ai-player  test-battery  popularity-contest  music  compression  code-golf  number  stack  atomic-code-golf  logic-gates  ascii-art  popularity-contest  code-golf  date  grid  code-challenge  game  code-golf  parsing  code-golf  math  geometry  sequence  popularity-contest  code-trolling  code-golf  string  restricted-source  code-golf  quine  king-of-the-hill  code-golf  math  code-golf  simulation  code-golf  ascii-art  code-challenge  sorting  optimization 
— Cristy
fonte
1
@JoeZ. Per CodeGolf? Perché? Finché funziona ...
— Cristy,
4
@Cristy sì, ma (finora) le domande sul consiglio del golf sono molto rare, mentre la maggior parte delle domande che richiedono un consiglio sono in realtà solo domande di programmazione generale - che sono fuori tema. Quindi, posso capire perché la prima reazione delle persone potrebbe essere "oh, questa è un'altra domanda che in realtà appartiene a SO", senza nemmeno pensare che potrebbe trattarsi di consigli sul golf. Mi piacerebbe davvero piacerebbe vedere più di questi in futuro, e forse ci sarà un tag per loro un giorno o giù di lì, e sarà chiaro immediatamente che si sa come utilizzare questo sito. ;)
— Martin Ender,
4
Se sono numeri interi compresi tra 0 e 5 inclusi, puoi fare la stessa cosa con x*x-y*y>9. È la stessa quantità di personaggi, ma potresti essere in grado di trovare una scorciatoia / alternativa a quell'approccio. Solo un altro modo di vederlo.
— Geobits,
5
Usa Python:3<x>y+1
— avall
2
Ho trovato molte soluzioni con la precedenza dell'operatore di Python, ad esempio y+3<2^x, ma la precedenza dell'operatore di C è diversa. Scommetto che c'è una soluzione a 7 caratteri, devo solo modificare il mio script per gestire la precedenza dell'operatore C
— Claudiu,

Risposte:

11

Dopo aver forzato brutalmente ogni utile combinazione di simboli con meno di 9 caratteri, ho scoperto che non esiste una soluzione più piccola di x>3&x-y>1.

Per divertimento, ecco alcune soluzioni funky di 9 personaggi che il bruto forcer ha trovato:

-x<~y>4>x
~y+x>2>>y
x*x-y*y>9
~y>x/~3*x
-3>>y>y-x
~y+x<<y>2

La forzatura bruta è stata fatta in Python, costruendo alberi di sintassi dall'alto verso il basso in cui nessun figlio può avere un operatore con precedenza inferiore rispetto al suo genitore secondo le regole di C. Per ridurre le possibilità, ho consentito solo valori letterali a una cifra e nessun operatore binario può avere due figli costanti. Non riuscivo a pensare a nessuna soluzione che avesse un valore letterale a due cifre o che costruisse una costante usando un operatore binario. Quindi ogni espressione è stata valutata per [0, 5] e se corrisponde viene stampata.

— orlp
fonte
Mi piace molto x*x-y*y>9. Forse dovresti provare anche costanti a più cifre? (anche, parentesi)
— John Dvorak,
@JanDvorak anche a me. Esprime bene la logica della "distanza tra xey". Penso che se lo pianifichi in un grafico, diventerebbe più ovvio.
— vedi l'
@JanDvorak Non credo che le parentesi possano mai essere una soluzione più piccola. Una soluzione più piccola può contenere un massimo di 8 caratteri, di cui 2 devono essere xye 2 devono essere tra parentesi, lasciando solo 4 caratteri di logica. Proverò a eseguire il bruto forcer con costanti a 2 cifre, ma non credo davvero che darà un risultato.
— orlp
Che ne dici di x, y, una costante, una coppia di parentesi e due operatori?
— John Dvorak,
@JanDvorak Mettiti al tappeto, (a#b)$cè il formato. Su abcdue devono essere xe y, lasciando 3 posizioni possibili per [0-9xy], e solo un capovolgimento xy. Sono solo operatori interessanti +-*/&|^<>, quindi 9 possibilità. Quindi le possibilità totali sono inferiori a 3 * 12 * 2 * 9 * 9 <5832.
— orlp
0

In risposta ai (fantastici) golf di orlp:

La correttezza deve venire prima di tutto

  • La maggior parte di questi si scompone per alcuni tipi interi. Ciò include la versione dall'OP
  • È interessante notare che essi fanno il lavoro per int16_t- per cui v'è il presupposto. Probabilmente i bit shift avrebbero bisogno di +16 per 32 bit ints (è praticamente ovunque in questi giorni). Questo li rende un personaggio più grande ...

L'unico modo "corretto" per scriverlo, l'IMO è (x>3) && (x > y+1), che può essere ridotto a x>3&x>y+1(9 caratteri).

(Devi davvero prendere in considerazione la possibilità di tipi (più grandi) senza segno, specialmente perché la non-firma è "contagiosa" nelle espressioni C ++. Suppongo che "aggiustare" che con gli static_cast<>s appropriati possa un po 'vanificare lo scopo ...)

AGGIORNARE

Con i seguenti test sono stato in grado di capire quali espressioni funzionano effettivamente in modo affidabile:

Live On Coliru

#define REPORT(caption, expr) do {\
    do_report(caption, [](T x, T y) -> bool { return (expr); }, #expr); } while (false)

template <typename T> struct driver {
    static void run() {
        std::cout << "\n" << __PRETTY_FUNCTION__ << "\n";

        // the only two correct implementations:
        REPORT("MASTER"  , (x>3) && (x>y+1));
        REPORT("GOLF"    , x>3&x>y+1);
        REPORT("lookup"  , "000000000000000000000000111000111100"[x*6+y]-'0');

        // failing sometimes:
        REPORT("question", (x>3)&(x-y>1));
        REPORT("orlp0"   , x>3&x-y>1);
        REPORT("orlp2"   , ~y+x>2>>y);
        REPORT("orlp3"   , x*x-y*y>9);
        REPORT("orlp4"   , ~y>x/~3*x);
        REPORT("orlp5"   , -3>>y>y-x);
        REPORT("orlp6"   , ~y+x<<y>2);

        // failing always
        REPORT("orlp1"   , -x<~y>4>x);
    }
private:
    static void do_report(std::string const& caption, bool (*f)(T,T), char const* expression) {
        std::string r;
        for (T x = 0; x < 6; ++x) for (T y = 0; y < 6; ++y) r += f(x, y)?'1':'0';
        bool const correct = "000000000000000000000000111000111100" == r;
        std::cout << (correct?"OK\t":"ERR\t") << r << "\t" << caption << "\t" << expression << "\n";
    }
};

int main() {
    driver<int8_t>::run();
    driver<int16_t>::run();
    driver<int32_t>::run();
    driver<int64_t>::run();

    driver<uint8_t>::run();
    driver<uint16_t>::run();
    driver<uint32_t>::run();
    driver<uint64_t>::run();
}

Uscita su coliru, qui per riferimento:

static void driver<T>::run() [with T = signed char]
OK  000000000000000000000000111000111100    MASTER  (x>3) && (x>y+1)
OK  000000000000000000000000111000111100    GOLF    x>3&x>y+1
OK  000000000000000000000000111000111100    lookup  "000000000000000000000000111000111100"[x*6+y]-'0'
OK  000000000000000000000000111000111100    question    (x>3)&(x-y>1)
OK  000000000000000000000000111000111100    orlp0   x>3&x-y>1
OK  000000000000000000000000111000111100    orlp2   ~y+x>2>>y
OK  000000000000000000000000111000111100    orlp3   x*x-y*y>9
OK  000000000000000000000000111000111100    orlp4   ~y>x/~3*x
OK  000000000000000000000000111000111100    orlp5   -3>>y>y-x
OK  000000000000000000000000111000111100    orlp6   ~y+x<<y>2
ERR 000000000000000000000000000000000000    orlp1   -x<~y>4>x

static void driver<T>::run() [with T = short int]
OK  000000000000000000000000111000111100    MASTER  (x>3) && (x>y+1)
OK  000000000000000000000000111000111100    GOLF    x>3&x>y+1
OK  000000000000000000000000111000111100    lookup  "000000000000000000000000111000111100"[x*6+y]-'0'
OK  000000000000000000000000111000111100    question    (x>3)&(x-y>1)
OK  000000000000000000000000111000111100    orlp0   x>3&x-y>1
OK  000000000000000000000000111000111100    orlp2   ~y+x>2>>y
OK  000000000000000000000000111000111100    orlp3   x*x-y*y>9
OK  000000000000000000000000111000111100    orlp4   ~y>x/~3*x
OK  000000000000000000000000111000111100    orlp5   -3>>y>y-x
OK  000000000000000000000000111000111100    orlp6   ~y+x<<y>2
ERR 000000000000000000000000000000000000    orlp1   -x<~y>4>x

static void driver<T>::run() [with T = int]
OK  000000000000000000000000111000111100    MASTER  (x>3) && (x>y+1)
OK  000000000000000000000000111000111100    GOLF    x>3&x>y+1
OK  000000000000000000000000111000111100    lookup  "000000000000000000000000111000111100"[x*6+y]-'0'
OK  000000000000000000000000111000111100    question    (x>3)&(x-y>1)
OK  000000000000000000000000111000111100    orlp0   x>3&x-y>1
OK  000000000000000000000000111000111100    orlp2   ~y+x>2>>y
OK  000000000000000000000000111000111100    orlp3   x*x-y*y>9
OK  000000000000000000000000111000111100    orlp4   ~y>x/~3*x
OK  000000000000000000000000111000111100    orlp5   -3>>y>y-x
OK  000000000000000000000000111000111100    orlp6   ~y+x<<y>2
ERR 000000000000000000000000000000000000    orlp1   -x<~y>4>x

static void driver<T>::run() [with T = long int]
OK  000000000000000000000000111000111100    MASTER  (x>3) && (x>y+1)
OK  000000000000000000000000111000111100    GOLF    x>3&x>y+1
OK  000000000000000000000000111000111100    lookup  "000000000000000000000000111000111100"[x*6+y]-'0'
OK  000000000000000000000000111000111100    question    (x>3)&(x-y>1)
OK  000000000000000000000000111000111100    orlp0   x>3&x-y>1
OK  000000000000000000000000111000111100    orlp2   ~y+x>2>>y
OK  000000000000000000000000111000111100    orlp3   x*x-y*y>9
OK  000000000000000000000000111000111100    orlp4   ~y>x/~3*x
OK  000000000000000000000000111000111100    orlp5   -3>>y>y-x
OK  000000000000000000000000111000111100    orlp6   ~y+x<<y>2
ERR 000000000000000000000000000000000000    orlp1   -x<~y>4>x

static void driver<T>::run() [with T = unsigned char]
OK  000000000000000000000000111000111100    MASTER  (x>3) && (x>y+1)
OK  000000000000000000000000111000111100    GOLF    x>3&x>y+1
OK  000000000000000000000000111000111100    lookup  "000000000000000000000000111000111100"[x*6+y]-'0'
OK  000000000000000000000000111000111100    question    (x>3)&(x-y>1)
OK  000000000000000000000000111000111100    orlp0   x>3&x-y>1
OK  000000000000000000000000111000111100    orlp2   ~y+x>2>>y
OK  000000000000000000000000111000111100    orlp3   x*x-y*y>9
OK  000000000000000000000000111000111100    orlp4   ~y>x/~3*x
OK  000000000000000000000000111000111100    orlp5   -3>>y>y-x
OK  000000000000000000000000111000111100    orlp6   ~y+x<<y>2
ERR 000000000000000000000000000000000000    orlp1   -x<~y>4>x

static void driver<T>::run() [with T = short unsigned int]
OK  000000000000000000000000111000111100    MASTER  (x>3) && (x>y+1)
OK  000000000000000000000000111000111100    GOLF    x>3&x>y+1
OK  000000000000000000000000111000111100    lookup  "000000000000000000000000111000111100"[x*6+y]-'0'
OK  000000000000000000000000111000111100    question    (x>3)&(x-y>1)
OK  000000000000000000000000111000111100    orlp0   x>3&x-y>1
OK  000000000000000000000000111000111100    orlp2   ~y+x>2>>y
OK  000000000000000000000000111000111100    orlp3   x*x-y*y>9
OK  000000000000000000000000111000111100    orlp4   ~y>x/~3*x
OK  000000000000000000000000111000111100    orlp5   -3>>y>y-x
OK  000000000000000000000000111000111100    orlp6   ~y+x<<y>2
ERR 000000000000000000000000000000000000    orlp1   -x<~y>4>x

static void driver<T>::run() [with T = unsigned int]
OK  000000000000000000000000111000111100    MASTER  (x>3) && (x>y+1)
OK  000000000000000000000000111000111100    GOLF    x>3&x>y+1
OK  000000000000000000000000111000111100    lookup  "000000000000000000000000111000111100"[x*6+y]-'0'
ERR 000000000000000000000000111001111100    question    (x>3)&(x-y>1)
ERR 000000000000000000000000111001111100    orlp0   x>3&x-y>1
ERR 111111011111001111000111111011111101    orlp2   ~y+x>2>>y
ERR 011111001111000111000011111001111100    orlp3   x*x-y*y>9
ERR 111111111111111111111111111111111111    orlp4   ~y>x/~3*x
ERR 111111011111001111000111111011111101    orlp5   -3>>y>y-x
ERR 111111011111001111000111111011111101    orlp6   ~y+x<<y>2
ERR 000000000000000000000000000000000000    orlp1   -x<~y>4>x

static void driver<T>::run() [with T = long unsigned int]
OK  000000000000000000000000111000111100    MASTER  (x>3) && (x>y+1)
OK  000000000000000000000000111000111100    GOLF    x>3&x>y+1
OK  000000000000000000000000111000111100    lookup  "000000000000000000000000111000111100"[x*6+y]-'0'
ERR 000000000000000000000000111001111100    question    (x>3)&(x-y>1)
ERR 000000000000000000000000111001111100    orlp0   x>3&x-y>1
ERR 111111011111001111000111111011111101    orlp2   ~y+x>2>>y
ERR 011111001111000111000011111001111100    orlp3   x*x-y*y>9
ERR 111111111111111111111111111111111111    orlp4   ~y>x/~3*x
ERR 111111011111001111000111111011111101    orlp5   -3>>y>y-x
ERR 111111011111001111000111111011111101    orlp6   ~y+x<<y>2
ERR 000000000000000000000000000000000000    orlp1   -x<~y>4>x

Sommario

Dato che ciò riguarda il "costo" della ripetizione degli elementi del codice sorgente, è possibile utilizzare una tabella di ricerca. Puoi "nascondere" la tabella di ricerca, quindi lo è anche

 LUT[x][y]

o 

 LUT[x*6+y]

Naturalmente puoi essere pedante e ottuso e rinominare la LUT

 L[x][y]

Quindi la mia "versione" è ... 7 caratteri . (Oppure crea una funzione ed L(x,y)è ancora più breve).

O, ancora più importante: corretto, testabile e mantenibile.

— sehe
fonte
Aggiunto un golf "vero". Non inferiore a 9 caratteri, ma il primo ad essere corretto!
— vedi l'
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.