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 Cristy
источник
1
@JoeZ. Для CodeGolf? Зачем? Пока это работает ...
Кристи
4
@ Кристи, да, но (пока) вопросы, касающиеся вопросов о гольфе, встречаются очень редко, в то время как большинство вопросов, требующих совета, на самом деле являются просто общими вопросами программирования, которые не имеют отношения к теме. Следовательно, я могу понять, почему первая реакция людей может быть «о, это еще один вопрос, который на самом деле принадлежит SO», даже не думая, что это может быть о совете по игре в гольф. На самом деле я хотел бы увидеть больше таких в будущем, и, возможно, когда-нибудь для них будет тег, и сразу станет ясно, что вы знаете, как использовать этот сайт. ;)
Мартин Эндер
4
Если они целые числа от 0..5 включительно, вы можете сделать то же самое с x*x-y*y>9. Это то же количество символов, но вы можете найти ярлык / альтернативу этому подходу. Просто еще один способ взглянуть на это.
Геобиц
5
Используйте Python:3<x>y+1
Avall
2
Я нашел много решений с приоритетом оператора Python, например y+3<2^x, но приоритет оператора C отличается. Я держу пари, что есть решение с 7 символами, просто нужно изменить мой сценарий, чтобы вместо этого использовать приоритет оператора 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, создавая синтаксические деревья сверху вниз, где ни один дочерний элемент не может иметь оператор с приоритетом ниже, чем его родительский в соответствии с правилами Си. Чтобы сократить возможности, я допустил только однозначные литералы, и ни у одного двоичного оператора не может быть двух постоянных детей. Я никак не мог придумать какое-либо решение, которое будет иметь двухзначный литерал, или решение, которое строит константу с использованием бинарного оператора. Затем каждое выражение было оценено для [0, 5] и, если оно совпадает, оно печатается.

orlp
источник
Мне очень нравится x*x-y*y>9. Возможно, вам стоит попробовать и многозначные константы? (также в скобках)
Джон Дворжак
@JanDvorak мне тоже. Это хорошо выражает логику «расстояния между x и y». Я думаю, что если вы нанесете это на график, это станет более очевидным.
Сехе
@JanDvorak Я не думаю, что круглые скобки могут быть меньшим решением. Меньшее решение может содержать до 8 символов, из которых 2 должны быть xy, а 2 должны быть круглыми скобками, оставляя только 4 символа логики. Я попробую запустить брутфорсер с 2-значными константами, но я действительно не думаю, что это даст результат.
orlp
Как насчет x, y, константы, пары скобок и двух операторов?
Джон Дворак
@JanDvorak Выбей себя, (a#b)$cэто формат. Из abcдвух должно быть xи y, оставляя 3 возможных местоположения [0-9xy], и только один бросок xy. Только интересные операторы +-*/&|^<>, так что 9 возможностей. Таким образом, суммарные возможности составляют менее 3 * 12 * 2 * 9 * 9 <5832.
15:15
0

В ответ на (удивительные) гольфы orlp:

Корректность должна быть на первом месте

  • Большинство из них разбиты на некоторые целочисленные типы. Это включает в себя версию от ОП
  • Интересно , они делают работу int16_t- так что есть предположение. Вероятно, сдвиги битов должны были бы +16 для 32-битных целых (это почти везде в наши дни). Это делает их персонаж больше ...

Единственный «правильный» способ написать это, IMO, это (x>3) && (x > y+1), возможно, игра в гольф x>3&x>y+1( до 9 символов).

(Вы действительно должны принять во внимание возможность (более крупных) типов без знака, тем более что unsigned-ness является «заразной» в выражениях 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();
}

Вывод на колиру, вот для справки:

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 символов, но первый будет правильным!
Сехе