Цель этого поста - собрать все советы по игре в гольф, которые можно легко применить, <all languages>а не конкретные.

Только отправляйте ответы, что его логика может быть применена к большинству языков

Пожалуйста, один совет за ответ

Объединить петли

Обычно вы можете объединить два последовательных цикла или два вложенных цикла в один.

До:

for (i=0; i<a; i++) foo();
for (i=0; i<b; i++) bar();

После:

for (i=0; i<a+b; i++) i<a?foo():bar();

Просто упомянуть очевидное:

Задайте вопрос о выборе алгоритма и попробуйте что-то совершенно новое.

Когда вы играете в гольф (особенно сложные проблемы, которые приводят к более длительным программам) слишком часто, вы можете придерживаться выбранного вами пути, не пытаясь использовать другие фундаментальные варианты. Конечно, вы можете играть в микро-гольф по одной или нескольким линиям за раз или как часть общей идеи, но часто не пытайтесь использовать совершенно другое решение.

Это было особенно заметно в Удар 495 (Капрекар), где отклонение от фактического алгоритма и поиск шаблонов, которые вы можете применить, чтобы получить тот же результат, были короче во многих языках (только не в J).

Недостатком является то, что вы, возможно, решаете одно и то же полдюжины раз. Но он работает практически на всех языках, кроме HQ9 + (где найти другой способ вывода Hello World было бы немного бесполезно).

Используйте тестовую разработку

Если код должен обрабатывать различные входные данные, тогда напишите комплексные тесты и упростите их выполнение очень быстро. Это позволяет попробовать рискованные трансформации по одному детскому шагу за раз. Тогда игра в гольф становится рефакторингом с извращенным намерением.

Попробуйте уменьшить логические высказывания

Например, если Aи Bявляются булевыми и вашим язык обрабатывает булевы как числа в некоторой степень, A and (not B)и A>Bэквивалентны. Например в Python

if A and not B:
    foo()

такой же как:

if A>B:
    foo()

Инициализируйте переменные, используя значения, которые у вас уже есть.

Вместо этого x=1попробуйте найти что-то, что уже равно 1.
Например, возвращаемое значение функции: printf("..");x=0;-> x=!printf("..");. Проще всего с 0, потому что вы всегда можете отрицать, или когда все, что вам нужно, это правильное значение истинности (и не волнует, если это 1 или 19).

Используйте одинарные ~для x+1иx-1

Этот прием применим к языкам, которые имеют унарный побитовый оператор отрицания ~и унарный регулярный оператор отрицания -.

Если ваша программа случайно содержит выражение -x-1, вы можете заменить его, ~xчтобы сохранить байты. Это происходит не слишком часто, но посмотрите, что произойдет, если мы отвергнем ( -) оба выражения: x+1равно -~x! Точно так же, x-1равно ~-x. (Подумайте, в какую сторону указывает тильда: справа есть +, слева есть -.)

Это полезно, потому что во всех языках, о которых я могу думать, эти операторы имеют более высокий приоритет, чем большинство операторов. Это позволяет сэкономить на скобках. Посмотрите, как мы сохраняем четыре байта здесь:

(x+1)*(y-1)     ==>    -~x*~-y

Сожмите пробел

Знайте правила для пробелов на вашем языке. Некоторым знакам препинания или другим символам может не понадобиться окружающий пробел. Рассмотрим эту функцию оболочки Борна :

f () { echo a; echo b; }

В оболочке Bourne ();есть метасимволы, и не нужно окружать их пробелами. Тем не менее, {}слова являются и нуждаются в пробеле, если они не находятся рядом с метасимволами. Мы можем поиграть в гольф на 4 поля рядом с ();, но мы должны оставить расстояние между {и echo.

f(){ echo a;echo b;}

В Common Lisp и PicoLisp , ()есть метасимволы. Рассмотрим этот код, чтобы найти среднее из двух чисел:

(/ (+ a b) 2)

Мы можем сыграть в гольф на 2 места.

(/(+ a b)2)

Некоторые языки имеют странные и тонкие правила для пробелов. Рассмотрим программу Ruby, которая выводит сумму и произведение строки целых чисел.

#!ruby -an
i=$F.map &:to_i
puts"#{i.reduce &:+} #{i.reduce &:*}"

Каждому &нужно пространство перед собой. В Ruby i=$F.map &:to_iозначает, i=$F.map(&:to_i)где &передается параметр блока. Но, i=$F.map&:to_iозначает, i=$F.map.&(:to_i)где &бинарный оператор.

Эта странность встречается в языках, таких как Perl или Ruby, которые используют неоднозначную пунктуацию. В случае сомнений используйте REPL или напишите короткие программы для проверки правил пробелов.

назначать функции новые имена, если они используются несколько раз

x = SomeLongFunctionName
x(somedata)
x(somemoredata)
etc

Однобуквенные имена переменных

У вас есть 52 из них; использовать их все! Не бойтесь пробовать разные подходы и сравнивать длины. Знать язык и специальные ярлыки / доступные функции библиотеки.

Используйте условный оператор.

Условный оператор

bool ? condition_true : condition_false

является более полезным, характерным, чем заявление IF .

if(a>b){r=a;}else{r=b;}

можно записать как

r=a>b?a:b;

Напишите объяснение вашего кода

Написание объяснения заставляет вас снова тщательно рассмотреть каждую часть вашего кода и сделать ваши мысли и выбор в написании определенного отрывка явным. При этом вы можете обнаружить, что возможны разные подходы, которые могут сэкономить несколько байтов, или что вы подсознательно сделали предположения, которые не обязательно выполняются.

Этот совет похож на вопрос о выборе алгоритма и попробуйте что-то совершенно новое ; тем не менее, я обнаружил, что этап написания того, как каждая часть должна работать, иногда имеет решающее значение для осознания альтернатив.

В качестве бонуса, ответы, включая объяснения, более интересны для других пользователей и, следовательно, с большей вероятностью будут проголосованы.

Дважды проверьте количество символов

Звучит как ежу понятно, но если вы будете осторожны, вы сможете «спасти» нескольких персонажей, ничего не делая!

Если вы используете Windows, вы можете вводить \r\nвместо обычного \rили \nкогда вы нажимаете Return, добавляя дополнительный байт на строку! Поверните управляющие символы, чтобы дважды проверить, что вы этого не делаете.

В Notepad ++ вы можете конвертировать все \r\nокончания строк, просто \rперейдя в Edit > EOL Conversion > UNIX/OSX Format.

Также убедитесь, что вы не включаете пробелы в число своих персонажей! Перевод строки в нижней строке вашего кода также несущественен, так что подсчитывать его тоже не нужно.

Внимательно прочитайте вопрос

Гольф-код - это не только понимание вопроса (что задается, а что нет , даже если это подразумевается в любой другой ситуации), а также создание кода, который (может) удовлетворять только то, что спрашивается.

Любой ввод, кроме того, что явно запрашивается, не должен обрабатываться. Если есть несколько тестовых случаев и нет общих требований, ваш код может работать только в этих случаях. И т.п.

Используйте побитовые операции для проверки чисел между 0 и любыми 2 ⁿ -1

Может быть, это немного необычный случай, но иногда он может пригодиться. Он основан на том факте, что все числа, к которым применяется m = 2 ⁿ -1, имеют самые правые n битов, равные 1.

Итак, 7 ₁₀ == 00000111 ₂ , 15 ₁₀ == 00001111 ₂ , 31 ₁₀ == 00011111 ₂ и так далее.

Хитрость есть x&~m. Это возвращает истину , когда xэто не от 0 до m(включительно), и ложь в противном случае. Он сохраняет 6 байтов из следующего кратчайшего эквивалентного выражения:, x>=0&&x<=mно, очевидно, работает только тогда, когда mудовлетворяет 2 ⁿ -1.

Повторно используйте параметры функции вместо новых переменных

Больше / меньше, чем для сохранения цифры:

//use:
if(n>9){A}else{B}
//instead of:
if(n<10){B}else{A}

Просто не забудьте поменять код с ifна, elseи они будут делать то же самое (или переключать стороны неравенства)!

Примечание: это может быть применено с любой степенью 10 и их минусами:...-100, -10, 10, 100...

(ссылка на источник)

Используйте> и <вместо> = и <=

При сравнении с жестко запрограммированными целочисленными значениями используйте >и <вместо >=и <=где это возможно. Например, используя

if(x>24&&x<51)

На 2 байта короче, чем при использовании

if(x>=25&&x<=50)

Избегайте преждевременных разрывов петли

Если при выполнении цикла выполняется проверка на наличие одного или нескольких экземпляров логической проверки, это может привести к тому, что более эффективная программа выйдет из цикла с первым истинным значением. Однако удаление разрыва и циклического прохождения всех итераций позволяет сократить код.

int main() {
bool m = false;
int n = 1000;
for (int i = 0; i < n; i++) {
if (i >= 100) {
m = true;
break; // remove this line
}
} 
return 0;
}

использовать -вместо!=

для числовых сравнений:

Если a равно b, это a-bприводит к 0ошибочности. Все, кроме 0правды; поэтому,
если используется в логическом контексте, a-b<=>a!=b

Если вы используете его с if/elseили с троичным оператором, это также может сэкономить вам один байт для равенства:
a==b?c:d<=>a-b?d:c

Сплит-строки для длинных массивов

В большинстве языков есть способ разбить строку на массив строк вокруг какого-либо токена. Это неизбежно будет короче литерала массива, когда длина достигнет порогового значения, зависящего от языка, поскольку дополнительные издержки на строку будут представлять собой одну копию токена с одним символом, а не (как минимум) двух разделителей строк.

Например, в GolfScript

["Foo""Bar""Baz""Quux"]  # 23 chars

становится

"Foo
Bar
Baz
Quux"n/  # 20 chars

Для некоторых языков порог составляет всего одну строку. Например, на Яве,

new String[]{"Foo"}  // 19 chars

становится

"Foo".split("~")  // 16 chars

Понять, что сделали другие люди

Помимо удовольствия, если вы изучаете код других людей, вы можете иногда найти хороший алгоритм, о котором вы не задумывались, или трюк (иногда очевидный), который вы пропускаете.

Иногда существует существующий ответ, который вы можете перевести на другой язык и воспользоваться его вкусностями.

знать приоритет вашего оператора

Всякий раз, когда вы комбинируете несколько выражений, проверяйте таблицу приоритетов операторов для вашего языка, чтобы увидеть, можете ли вы изменить порядок вещей, чтобы сохранить скобки.

Примеры:

• На всех языках, которые я знаю, побитовые операторы имеют более высокий приоритет, чем логические операторы: не (a&b)&&cнуждается в скобках: так a&b&&cже, как (a*b)+cи нет.
• a+(b<<c)можно переписать как a+b*2**c.
  Это ничего не сохраняет для этого примера, но будет, если cэто маленький целочисленный литерал (<14).
• Битовые операции имеют меньший приоритет, чем большинство арифметических операций, поэтому, если ваш язык неявно преобразует логическое значение в int, вы можете сохранить байт a<b&&c<dс помощью a<b&c<d(если только вам не нужна оценка короткого замыкания)

Короче петли

Если у вас есть Xоператоры {внутри }цикла for, вы можете переместить X-1операторы (внутри )цикла for после второй точки for(blah;blah;HERE)с запятой, чтобы сохранить 3 байта. (разделите операторы запятыми ,)

Вместо

for(int i=0;i<9;){s+=s.length();println(i++);}

Вы можете переместить одно из утверждений в (фигурные скобки цикла for, )оставляя другое вне

for(int i=0;i<9;println(i++))s+=s.length();

и сохраните 3 байта (еще 1 байт благодаря @ETHProductions)

Проще говоря,

вместо

for(blah;blah;){blah 1;blah 2;...;blah X}

переместить утверждения вокруг, чтобы вы в конечном итоге с этим

for(blah;blah;blah 2,...,blah X)blah 1;

и сохранить 3 байта

Используйте одинарные ~для a-b-1иa+b+1

В дополнение к предложениям @Lynn относительно x+1→ -~x; и x-1→~-x , вы также можете играть в гольф a-b-1и a+b+1.

a-b-1    // 5 bytes
a+~b     // 4 bytes

a+b+1    // 5 bytes
a-~b     // 4 bytes

Это может выглядеть как совет, который вы не будете использовать все так часто, вроде как ~xвместо того, -x-1чтобы встречаться не часто, но я использовал его достаточно много раз, чтобы увидеть его здесь как полезный совет. Особенно с индексированием массива вы можете использовать их выше в некоторых случаях.

Сжатие или / и полосы

Простой трюк, который я придумал, пытаясь сжать длинную полосу условий, прикованных цепью ands (или ors, в данном случае просто заменить «all» на «any»).

Например:

if a>0 and a<10 and a+b==4 and a+3<1:

становится

if all([a>0,a<10,a+b==4,a+3<1]):

Положитесь на компилятор, чтобы обеспечить требуемую производительность.

Убедитесь, что вы знаете, какие оптимизации гарантированы компилятором и на каких уровнях оптимизации, и используйте их свободно. И даже если производительность не является проблема требования, вы можете проверить с оптимизациями на, а затем только скидку на один символ , потому что ваш код все еще технически действует без флага компилятора.

Рассмотрим следующую функцию Haskell для вычисления 2 ^ n (игнорируя тот факт, что Haskell уже имеет встроенный оператор возведения в степень или три) (23 символа):

p 0=1;p x=p(x-1)+p(x-1)

Проблема в том, что это ужасно медленно, оно работает в геометрической прогрессии. Это может сделать ваш код непроверенным или потерять любые ограничения производительности, заданные вопросом. У вас может возникнуть соблазн использовать временную переменную или литерал функции, вызываемой немедленно, чтобы избежать повторных вызовов функций (25 символов):

p 0=1;p x=(\y->y+y)$p$x-1

Но компилятор уже может сделать это за вас, вам просто нужно установить -Oфлаг компилятора! Вместо того, чтобы тратить несколько лишних символов на сайт для устранения общих подвыражений вручную, просто скажите компилятору выполнить базовую оптимизацию для вас, чтобы получить всего один или два символа во всей программе.

Может быть, несколько очевидно, но ...

Используйте оператор возвращаемых значений

Имейте в виду, что оператор присваивания возвращает значение!

Например, если вы хотите добавить y к x, а затем проверить, больше ли x чем-то, вы можете сделать

if(25<x+=y)

вместо

x+=y;if(x>25)

Или, может быть, вы хотите найти длину строки после обрезки:

strlen(s=trim(s))

Скорее, чем

s=trim(s);strlen(s)

Использовать языковую версию / компилятор / особенности среды / новые функции

Это особенно полезно для полиглотов , но может быть применено к другим задачам. Иногда ошибка компилятора может отставать от байта, ошибка реализации может позволить вам сэкономить несколько символов, или действительно передовая функция может улучшить ваш счет.

Комбинируйте множественные / вложенные, если проверки, используя И / Или, когда это возможно.

то есть:

if (a && (b || c)) {

}

вместо:

if (a) {
    if (b) {
        //Do Stuff
    } elseif (c) {
        //Do same stuff
    }
}

Найдите лучшие способы инициализации ваших переменных

Некоторые другие ответы уже были близки к упоминанию об этом, но во многих (строго типизированных?) Языках короче инициализировать xкак пустую строку, например:

x:=""

или xкак пустая руна (символ) как:

x:=''

чем

var x string

а также

var x rune

Использование ранее существующих значений, очевидно, предпочтительнее, но не так просто.