X większe niż 3 z co najmniej 2 różnicami między X i Y

11

Próbuję zagrać w golfa w C ++. Czy można skrócić ten warunek?

X > 3 & X - Y > 1

(Oczywiście oprócz usuwania białych znaków).

Więc Xjest przynajmniej 4ale X >= Y + 2.

Xi Ysą liczbami całkowitymi w przedziale [0,5].

Próbowałem znaleźć formułę bitową, ale nie udało mi się.

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
źródło
1
@JoeZ. Dla CodeGolf? Czemu? Tak długo, jak to działa ...
Cristy
4
@Cristy tak, są, ale (jak dotąd) pytania o porady dotyczące gry w golfa są bardzo rzadkie, podczas gdy większość pytań o porady to w rzeczywistości ogólne pytania programistyczne - które są nie na temat. Dlatego rozumiem, dlaczego pierwszą reakcją ludzi może być „och, to kolejne pytanie, które tak naprawdę należy do SO”, nawet nie myśląc, że może to dotyczyć porad golfowych. Chciałbym zobaczyć ich więcej w przyszłości, a może kiedyś będzie dla nich tag i od razu stanie się jasne, że wiesz, jak korzystać z tej witryny. ;)
Martin Ender
4
Jeśli są liczbami całkowitymi od 0..5 włącznie, możesz zrobić to samo z x*x-y*y>9. Jest to ta sama liczba znaków, ale możesz znaleźć skrót / alternatywę dla tego podejścia. Po prostu inny sposób patrzenia na to.
Geobits
5
Użyj Pythona: 3<x>y+1
avall
2
Znalazłem wiele rozwiązań z pierwszeństwem operatora Pythona, np. y+3<2^xPierwszeństwo operatora C jest inne. Założę się, że istnieje 7-znakowe rozwiązanie, po prostu muszę zmodyfikować skrypt, aby zajął się priorytetem operatora C
Claudiu

Odpowiedzi:

11

Po brutalnym wymuszeniu każdej użytecznej kombinacji symboli poniżej 9 znaków, znalazłem rozwiązanie nie mniejsze niż x>3&x-y>1.

Oto zabawne rozwiązania dla 9 postaci, które brutalny forcer znalazł:

-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

W Pythonie dokonano brutalnego wymuszania, budując odgórne drzewa składniowe, w których żadne dziecko nie może mieć operatora o priorytecie niższym niż jego rodzic, zgodnie z regułami języka C. Aby ograniczyć możliwości, dopuściłem tylko literały jednocyfrowe i żaden operator binarny nie może mieć dwóch stałych dzieci. Nie mogłem wymyślić żadnego rozwiązania, które miałoby dwucyfrowy literał lub takiego, który buduje stałą za pomocą operatora binarnego. Następnie każde wyrażenie zostało ocenione dla [0, 5] i jeśli pasuje, zostanie wydrukowane.

orlp
źródło
Bardzo mi się podoba x*x-y*y>9. Być może powinieneś również wypróbować stałe wielocyfrowe? (także nawiasy)
John Dvorak,
@JanDvorak ja też. Dobrze wyraża logikę „odległości między xiy”. Myślę, że jeśli spiszesz to na wykresie, stanie się to bardziej oczywiste.
patrz
@JanDvorak Nie sądzę, aby nawiasy były mniejszym rozwiązaniem. Mniejsze rozwiązanie może zawierać maksymalnie 8 znaków, z których 2 muszą być xy, a 2 muszą być nawiasami, pozostawiając tylko 4 znaki logiki. Spróbuję uruchomić brutalny forcer z dwucyfrowymi stałymi, ale tak naprawdę nie sądzę, że da to wynik.
orlp
Co powiesz na x, y, stałą, parę nawiasów i dwa operatory?
John Dvorak,
@ JanDvorak Knock out, (a#b)$cjest formatem. Z abcdwóch musi być xi y, pozostawiając 3 możliwe lokalizacje [0-9xy]i tylko jedno odwrócenie xy. Są tylko interesujący operatorzy +-*/&|^<>, więc 9 możliwości. Zatem łączne możliwości są mniejsze niż 3 * 12 * 2 * 9 * 9 <5832.
orlp
0

W odpowiedzi na (niesamowite) golfa orlp:

Poprawność musi być na pierwszym miejscu

  • Większość z nich rozkłada się na niektóre typy liczb całkowitych. Obejmuje to wersję z PO
  • Co ciekawe to zrobić pracę za int16_t- więc nie jest to założenie. Prawdopodobnie przesunięcia bitów wymagałyby +16 dla 32-bitowych liczb całkowitych (w dzisiejszych czasach jest to prawie wszędzie). To sprawia, że ​​postać jest większa ...

Jedynym „poprawnym” sposobem na napisanie go jest IMO (x>3) && (x > y+1), który może być golfowany do x>3&x>y+1(9 znaków).

(Naprawdę musisz wziąć pod uwagę możliwość (większych) typów niepodpisanych, zwłaszcza, że ​​niepodpisana jest „zaraźliwa” w wyrażeniach C ++. Podejrzewam, że „naprawienie”, które przy pomocy odpowiednich static_cast<>znaków snułoby cel ...

AKTUALIZACJA

Dzięki następującym testom udało mi się ustalić, które wyrażenia faktycznie działają niezawodnie:

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

Dane wyjściowe dotyczące coliru, tutaj w celach informacyjnych:

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

streszczenie

Ponieważ chodzi o „koszt” powtarzania elementów kodu źródłowego, możesz użyć tabeli odnośników. Możesz „ukryć” tabelę odnośników, więc jest to albo

 LUT[x][y]

lub 

 LUT[x*6+y]

Oczywiście możesz być pedantyczny, tępy i zmienić nazwę LUT

 L[x][y]

Więc moja „wersja” to ... 7 znaków . (Lub wykonaj, jeśli funkcja iL(x,y) jest jeszcze krótsza).

Lub, co ważniejsze: poprawne, testowalne i konserwowalne.

sehe
źródło
Dodano „prawdziwy” golf. Nie mniej niż 9 znaków, ale pierwszy z nich jest poprawny!
patrz