Мета цієї публікації - зібрати всі поради щодо гольфу, які можна легко застосувати, <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();

Відзначимо лише очевидне:

Поставте під сумнів свій вибір алгоритму та спробуйте щось зовсім нове.

При гольфі (особливо складніші проблеми, що призводять до більш тривалих програм), занадто часто ви можете дотримуватися шляху, який ви вибрали вперше, не намагаючись інших основних варіантів. Звичайно, ви можете мікро-гольф одночасно або кілька рядків або частина загальної ідеї, але часто не намагаєтесь зовсім інше рішення.

Це було особливо помітно в Hitting 495 (Kaprekar), де відхилення від власне алгоритму та пошук шаблонів, до яких можна застосувати, щоб дійти до того ж результату, було коротше у багатьох мовах (тільки не 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; }

У оболонці Борна ();є метахарактеристиками та не потребують навколишнього пробілу. Однак {}це слова та потрібні пробіли, якщо вони не поруч із метахарактеристиками. Ми можемо відіграти 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, додаючи додатковий байт на рядок! Поверніть контрольні символи лише для того, щоб перевірити, чи не робите ви цього.

У «Блокноті ++» ви можете конвертувати всі \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)

Уникайте передчасних розривів циклу

Якщо бігати через цикл для перевірки наявності 1 або більше екземплярів булевої перевірки, можливо, для ефективнішої програми вийде цикл на перше справжнє значення. Однак усунення розриву та циклічного перегляду всіх ітерацій дозволяє скоротити код.

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призводить 0, що falsy. Ніщо інше, ніж 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

Для деяких мов поріг такий же низький, як одна рядок. Наприклад, на Java,

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-loop, ви можете перемістити X-1оператори (всередині )циклу for-loop після другої крапки for(blah;blah;HERE)з комою, щоб зберегти 3 байти. (відокремте висловлювання за допомогою коми ,)

Замість

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

ви можете перемістити одне із висловлювань у (дужки for-loop, )поки не залишаєте інше

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, а потім перевірити, чи х більше, ніж щось, ви можете зробити

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як порожня руна (char), як:

x:=''

ніж

var x string

і

var x rune

Використання попередньо існуючих значень, очевидно, бажано, але не так просто.