X größer als 3 mit mindestens 2 Unterschieden zwischen X und Y.

11

Ich versuche, etwas C ++ zu spielen. Ist es möglich, diesen Zustand zu verkürzen?

X > 3 & X - Y > 1

(Abgesehen vom Entfernen von Leerzeichen natürlich.)

Also Xist zumindest 4doch X >= Y + 2.

Xund Ysind ganze Zahlen im Intervall [0,5].

Ich habe versucht, eine bitweise Formel zu finden, bin aber gescheitert.

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
quelle
1
@ JoeZ. Für CodeGolf? Warum? Solange es funktioniert ...
— Cristy
4
@Cristy ja, aber (bisher) Fragen zu Golf-Ratschlägen sind sehr selten, während die meisten Fragen, die um Rat gefragt werden, in der Tat nur allgemeine Programmierfragen sind - die nicht zum Thema gehören. Daher kann ich verstehen, warum die erste Reaktion der Leute sein könnte: "Oh, das ist eine andere Frage, die tatsächlich zu SO gehört", ohne zu denken, dass es sich um Golf-Ratschläge handeln könnte. Ich würde gerne in Zukunft mehr davon sehen, und vielleicht wird es eines Tages ein Tag für sie geben, und es wird sofort klar sein, dass Sie wissen, wie man diese Seite benutzt. ;)
— Martin Ender
4
Wenn es sich um ganze Zahlen zwischen einschließlich 0 und 5 handelt, können Sie dasselbe tun x*x-y*y>9. Es ist die gleiche Anzahl von Zeichen, aber Sie können möglicherweise eine Verknüpfung / Alternative zu diesem Ansatz finden. Nur eine andere Sichtweise.
— Geobits
5
Verwenden Sie Python:3<x>y+1
— Avall
2
Ich habe viele Lösungen mit Pythons Operator-Priorität gefunden, z. B. y+3<2^xaber Cs Operator-Priorität ist anders. Ich wette, es gibt eine 7-Zeichen-Lösung. Ich muss nur mein Skript ändern, um stattdessen die Priorität des C-Operators zu berücksichtigen
— Claudiu,

Antworten:

11

Nachdem ich jede nützliche Kombination von Symbolen unter 9 Zeichen brutal erzwungen habe, habe ich festgestellt, dass es keine kleinere Lösung als gibt x>3&x-y>1.

Zum Spaß hier einige funky 9-Zeichen-Lösungen, die der Brute Forcer gefunden hat:

-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

Brute Forcing wurde in Python durchgeführt, wobei Top-Down-Syntaxbäume erstellt wurden, in denen kein Kind einen Operator haben darf, dessen Priorität gemäß den Regeln von C niedriger ist als die des Elternteils. Um die Möglichkeiten einzuschränken, habe ich nur einstellige Literale zugelassen, und kein binärer Operator darf zwei konstante untergeordnete Elemente haben. Ich konnte mir unmöglich eine Lösung vorstellen, die ein zweistelliges Literal hätte oder eine Konstante, die einen binären Operator verwendet. Dann wurde jeder Ausdruck auf [0, 5] ausgewertet und wenn er übereinstimmt, wird er gedruckt.

— orlp
quelle
Ich mag es wirklich x*x-y*y>9. Vielleicht sollten Sie auch mehrstellige Konstanten ausprobieren? (auch in Klammern)
— John Dvorak
@ JanDvorak mich auch. Es drückt gut die Logik des "Abstandes zwischen x und y" aus. Ich denke, wenn Sie dies in einem Diagramm darstellen, wird es offensichtlicher.
— sehe
@ JanDvorak Ich glaube nicht, dass Klammern jemals eine kleinere Lösung sein können. Eine kleinere Lösung kann maximal 8 Zeichen umfassen, von denen 2 xyund 2 die Klammern sein müssen, wobei nur 4 Zeichen Logik übrig bleiben. Ich werde versuchen, den Brute Forcer mit zweistelligen Konstanten auszuführen, aber ich glaube wirklich nicht, dass dies zu einem Ergebnis führen wird.
— Orlp
Wie wäre es mit x, y, einer Konstanten, zwei Klammern und zwei Operatoren?
— John Dvorak
@ JanDvorak Knock dich aus, (a#b)$cist das Format. Von abczwei muss xund sein y, wobei 3 mögliche Positionen für [0-9xy]und nur ein Flip von übrig bleiben xy. Nur interessante Betreiber sind +-*/&|^<>, also 9 Möglichkeiten. Somit sind die Gesamtmöglichkeiten weniger als 3 * 12 * 2 * 9 * 9 <5832.
— orlp
0

Als Antwort auf die (fantastischen) Golfplätze von orlp:

Die Richtigkeit muss an erster Stelle stehen

  • Die meisten davon sind für einige ganzzahlige Typen aufgeschlüsselt. Dies beinhaltet die Version aus dem OP
  • Interessanter sie tun Arbeit für int16_t- so gibt die Annahme. Wahrscheinlich müssten die Bitverschiebungen für 32-Bit-Ints +16 betragen (das ist heutzutage so ziemlich überall). Das macht sie zu einem größeren Charakter ...

Die einzige "richtige" Art, es zu schreiben, ist IMO (x>3) && (x > y+1), die auf x>3&x>y+1(9 Zeichen) reduziert werden kann .

(Sie müssen wirklich die Möglichkeit von (größeren) vorzeichenlosen Typen in Betracht ziehen, insbesondere da vorzeichenlose Typen in C ++ - Ausdrücken "ansteckend" sind. Ich nehme an, dass das "Korrigieren" mit den entsprechenden static_cast<>s den Zweck irgendwie zunichte machen würde ...)

AKTUALISIEREN

Mit den folgenden Tests konnte ich herausfinden, welche Ausdrücke tatsächlich zuverlässig funktionieren:

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();
}

Ausgabe auf coliru, hier als Referenz:

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

Zusammenfassung

Da dies etwa die "Kosten" für das Wiederholen von Quellcodeelementen betrifft, können Sie eine Nachschlagetabelle verwenden. Sie können die Nachschlagetabelle "ausblenden", also ist es auch so

 LUT[x][y]

oder 

 LUT[x*6+y]

Natürlich können Sie pedantisch und stumpf sein und die LUT umbenennen

 L[x][y]

Meine "Version" ist also ... 7 Zeichen . (Oder machen Sie, wenn eine Funktion und L(x,y)noch kürzer ist).

Oder, was noch wichtiger ist: korrekt, überprüfbar und wartbar.

— sehe sehen
quelle
Ein "echtes" Golfspiel hinzugefügt. Nicht kürzer als 9 Zeichen, aber das erste, das korrekt ist!
— sehe
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.