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