X більший за 3, принаймні у 2 різниці між X і Y

11

Я намагаюся покататися на C ++. Чи можна скоротити цей стан?

X > 3 & X - Y > 1

(Окрім видалення пробілів, звичайно.)

Отже, Xпринаймні, 4але X >= Y + 2.

Xі Yє цілими числами в інтервалі [0,5].

Я намагався знайти якусь побітну формулу, але не вдався.

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 
— Хрусткий
джерело
1
@JoeZ. Для CodeGolf? Чому? Поки це працює ...
— Крісті
4
@Cristy так, але вони є, але (поки що) питання, які задають поради щодо гольфу, є дуже рідкісними, тоді як більшість питань, які задають поради, - це справді загальні питання програмування - які є поза темою. Отже, я можу зрозуміти, чому перша реакція людей може бути: "о, це ще одне питання, яке насправді належить до SO", навіть не думаючи, що це може бути порада щодо гольфу. Насправді я хотів би побачити більше таких у майбутньому, і, можливо, там буде якийсь тег для них якийсь день або близько того, і відразу буде зрозуміло, що ви знаєте, як користуватися цим сайтом. ;)
— Мартін Ендер
4
Якщо вони складають цілі числа від 0 до 5 включно, ви можете зробити те саме x*x-y*y>9. Це однакова кількість символів, але ви, можливо, зможете знайти ярлик / альтернативу такому підходу. Просто ще один погляд на це.
— Геобіт
5
Використовуйте Python:3<x>y+1
— avall
2
Я знайшов багато рішень з пріоритетом оператора Python, наприклад y+3<2^x, але пріоритет оператора C інший. Я думаю, що існує 7-char рішення, просто потрібно змінити мій сценарій, щоб мати справу з пріоритетом оператора C
— Claudiu

Відповіді:

11

Після жорстокого примусового використання будь-якої корисної комбінації символів під 9 символів, я знайшов рішення не меншим, ніж x>3&x-y>1.

Для розваги ось кілька стильних рішень з 9 символів, які знайшов грубий форцер:

-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

Брутне форсування було здійснено в Python, будуючи синтаксичні дерева зверху вниз, де жодна дитина не може мати оператора з пріоритетом, ніж його батьківський, згідно з правилами C. Щоб скоротити можливості, я дозволяв лише одноцифрові літерали, і жоден бінарний оператор не може мати двох постійних дітей. Я, можливо, не міг придумати жодного рішення, яке мало б двоцифрове буквальне, або таке, яке будує константу за допомогою двійкового оператора. Потім кожен вираз оцінювали за [0, 5], і якщо він відповідає, він надрукується.

— orlp
джерело
Мені дуже подобається x*x-y*y>9. Можливо, вам слід спробувати багатозначні константи? (також дужки)
— Іван Дворак
@JanDvorak мене теж. Це добре виражає логіку "відстані між х і у". Я думаю, якби ви задумали це в діаграмі, це стане очевидніше
— sehe
@JanDvorak Я не думаю, що круглі дужки колись можуть бути меншим рішенням. Меншим рішенням може бути максимум 8 символів, з яких 2 повинні бути xy, а 2 повинні бути в дужках, залишаючи лише 4 символи логіки. Я спробую запустити грубого форсера з двозначними константами, але я дійсно не думаю, що це дасть результат.
— orlp
Як щодо x, y, константа, пара дужок і два оператори?
— Джон Дворак
@JanDvorak Вибийте себе, (a#b)$cце формат. З abcдвох повинні бути xі y, залишивши 3 можливих місця для [0-9xy], і лише один фліп xy. Лише цікаві оператори +-*/&|^<>, тож 9 можливостей. Таким чином, загальні можливості менше 3 * 12 * 2 * 9 * 9 <5832.
— orlp
0

У відповідь на (приголомшливі) гольфи orlp:

Коректність повинна вийти на перше місце

  • Більшість із них розбиваються на деякі цілі типи. Сюди входить версія з ОП
  • Цікаво , вони роблять роботу int16_t- так що є припущення. Можливо, бітовим змінам знадобиться +16 для 32-бітових ints (це майже всюди в ці дні). Це робить їх характер більшим ...

Єдиний «правильний» спосіб його написання - ІМО (x>3) && (x > y+1), який може бути переведений на гольф x>3&x>y+1( до 9 символів).

(Вам дійсно потрібно враховувати можливість (більших) неподписаних типів, тим більше, що неподписаність є "заразливою" у виразах C ++. Я вважаю, що "виправлення", яке за допомогою відповідних static_cast<>s якось переможе мету ...)

ОНОВЛЕННЯ

За допомогою наступних тестів я зміг зрозуміти, які вирази справді працюють надійно:

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

Вихід на coliru, тут для довідки:

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

Підсумок

Оскільки це стосується "вартості" повторення елементів вихідного коду, ви можете використовувати таблицю пошуку. Ви можете «приховати» таблицю пошуку, так що вона є або

 LUT[x][y]

або 

 LUT[x*6+y]

Звичайно, ви можете бути педантичним і тупим і перейменовувати LUT

 L[x][y]

Тож моя "версія" - це 7 символів . (Або зробіть, якщо функція і L(x,y)ще коротша).

Або, що ще важливіше: правильне, перевірене та ретельне.

— sehe
джерело
Додано "справжній" гольф. Не коротше 9 символів, але перший правильний!
— sehe
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.