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
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.