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 символов, но первый будет правильным!
— Сехе
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.