Какие общие советы у вас есть для игры в гольф в Си? Я ищу идеи, которые могут быть применены к кодовым проблемам гольфа в целом, которые, по крайней мере, несколько специфичны для C (например, «удалить комментарии» - это не ответ). Пожалуйста, оставьте один совет за ответ. Также, пожалуйста, укажите, относится ли ваш совет к C89 и / или C99 и работает ли он только на определенных компиляторах.

Используйте побитовый XOR для проверки неравенства между целыми числами:

if(a^b)вместо того, чтобы if(a!=b)сохранить 1 символ.

• mainСписок аргументов Abuse для объявления одной или нескольких целочисленных переменных:

  main(a){for(;++a<28;)putchar(95+a);}
  

  (ответ на Алфавит на языках программирования )

  Это решение также использует тот факт, что a(aka argc) начинается как 1, при условии, что программа вызывается без аргументов.

• Используйте глобальные переменные для инициализации вещей до нуля:

  t[52],i;main(c){for(;i<52;)(c=getchar())<11?i+=26:t[i+c-97]++;
  for(i=27;--i&&t[i-1]==t[i+25];);puts(i?"false":"true");}
  

  (ответ на Anagram Code Golf! )

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

main(){                                                                                     

int i = 0;                                                                                  
int j = 1;                                                                                  
if(1)                                                                                       
    i=j,j+=1,printf("%d %d\n",i,j); // multiple statements are all executed                                                  
else                                                                                        
    printf("failed\n");                                                                     

}

Выходы: 1 2

Избегайте катастрофических объявлений типа аргумента функции

Если вы объявляете функцию, в которой все пять аргументов являются ints, то жизнь хороша. ты можешь просто написать

f(a,b,c,d,e){

Но предположим, что это dдолжно быть charили даже int*. Тогда ты облажался! Если одному параметру предшествует тип, все они должны быть:

f(int a,int b,int c,int*d,int e){

Но ждать! Есть способ обойти этот катастрофический взрыв бесполезных персонажей. Это выглядит так:

f(a,b,c,d,e) int *d; {

Это даже экономит стандартное mainобъявление, если вам нужно использовать аргументы командной строки:

main(c,v)char**v;{

на два байта короче

main(int c,char**v){

Я был удивлен, обнаружив это, так как я до сих пор не сталкивался с этим на PPCG.

Вместо> = и <= вы можете просто использовать целочисленное деление (/), когда сравниваемые значения выше нуля, что сохраняет один символ. Например:

putchar(c/32&&126/c?c:46); //Prints the character, but if it is unprintable print "."

Что, конечно, все еще можно сжать, используя, например, просто> и ^ (умный способ избежать написания && или || в некоторых случаях).

putchar(c>31^c>126?c:46);

Трюк с целочисленным делением, например, полезен для определения, является ли число меньше 100, так как это сохраняет символ:

a<100 vs 99/a

Это также хорошо в тех случаях, когда требуется более высокий приоритет.

Некоторые компиляторы, такие как GCC, позволяют опускать базовые #includeтипы s, param и return для main.

Ниже приведена действительная программа C89 и C99, которая компилирует (с предупреждениями) GCC:

main(i) { printf("%d", i); }

Обратите внимание, что отсутствует #includefor stdio.h, отсутствует тип возвращаемого значения for mainи отсутствует объявление типа for i.

Тройной условный оператор ?:может часто использоваться в качестве подставки в простых if- elseзаявления на значительной экономии средств.

В отличие от эквивалента в c ++, оператор формально не выдает lvalue , но некоторые компиляторы (в частности, gcc) позволят вам с этим справиться, что является хорошим бонусом.

http://graphics.stanford.edu/~seander/bithacks.html

Биты хорошие.

~-x = x - 1
-~x = x + 1

Но с разными приоритетами, и не меняйте х, как ++ и -. Также вы можете использовать это в действительно определенных случаях: ~ 9 короче, чем -10.

if(!(x&y)) x | y == x ^ y == x + y
if(!(~x&y)) x ^ y == x - y

Это более эзотерично, но у меня была возможность использовать его. Если вас не волнует короткое замыкание

x*y == x && y
if(x!=-y) x+y == x || y

Также:

if(x>0 && y>0) x/y == x>=y   

Используйте лямбды (непортативно)

Вместо

f(int*a,int*b){return*a>*b?1:-1;}
...
qsort(a,b,4,f);

или (только gcc)

qsort(a,b,4,({int L(int*a,int*b){a=*a>*b?1:-1;}L;}));

или (llvm с поддержкой блоков)

qsort_b(a,b,4,^(const void*a,const void*b){return*(int*)a>*(int*)b?1:-1;});

попробуй что-то вроде

qsort(a,b,4,"\x8b\7+\6\xc3");

... где строка в кавычках содержит инструкции на машинном языке вашей функции "лямбда" (соответствует всем требованиям ABI платформы).

Это работает в средах, в которых строковые константы помечены как исполняемые. По умолчанию это верно для Linux и OSX, но не для Windows.

Один глупый способ научиться писать свои собственные «лямбда-функции» - это написать функцию в C, скомпилировать ее, проверить что-то вроде этого objdump -Dи скопировать соответствующий шестнадцатеричный код в строку. Например,

int f(int*a, int*b){return *a-*b;}

... при компиляции с gcc -Os -cцелью Linux x86_64 генерирует что-то вроде

0:   8b 07                   mov    (%rdi),%eax
2:   2b 06                   sub    (%rsi),%eax
4:   c3                      retq

GNU CC goto:

Вы можете вызывать эти «лямбда-функции» напрямую, но если код, который вы вызываете, не принимает параметры и не собирается возвращаться, вы можете использовать gotoдля сохранения несколько байтов. Так что вместо

((int(*)())L"ﻫ")();

или (если в вашей среде нет арабских символов)

((int(*)())L"\xfeeb")();

Пытаться

goto*&L"ﻫ";

или же

goto*&L"\xfeeb";

В этом примере eb feэто машинный язык x86 для чего-то подобного for(;;);и простой пример чего-то, что не принимает параметров и не собирается возвращать :-)

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

#include<stdio.h>
int f(int a){
 if(!a)return 1;
 goto*&L"\xc3c031"; // return 0;
 return 2; // never gets here
}
int main(){
 printf("f(0)=%d f(1)=%d\n",f(0),f(1));
}

Приведенный выше пример (может компилироваться и запускаться в Linux с gcc -O) чувствителен к макету стека.

РЕДАКТИРОВАТЬ: В зависимости от вашей цепочки инструментов, вам, возможно, придется использовать -zexecstackфлаг компиляции.

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

Используйте курсоры вместо указателей. Захватите brk()в начале и используйте его как указатель базы .

char*m=brk();

Затем создайте #define для доступа к памяти.

#define M [m]

Mстановится постфиксом, *применяемым к целым числам. (Старый трюк [x] == x [a].)

Но это еще не все! Тогда у вас могут быть аргументы и возвраты указателей в функциях, которые короче макросов (особенно если вы сокращаете «возврат»):

f(x){return x M;} //implicit ints, but they work like pointers
#define f(x) (x M)

Чтобы сделать курсор из указателя, вы вычитаете базовый указатель, получая ptrdiff_t, который усекается в int, потери - это ваш бизнес.

char *p = sbrk(sizeof(whatever)) - m;
strcpy(m+p, "hello world");

Эта техника используется в моем ответе на « Напиши интерпретатор для нетипизированного лямбда-исчисления» .

Определите параметры вместо переменных.

f(x){int y=x+1;...}

f(x,y){y=x+1;...}

Вам не нужно фактически передавать второй параметр.

Также вы можете использовать приоритет оператора для сохранения скобок.
Например, (x+y)*2может стать x+y<<1.

Так как обычно EOF == -1, используйте побитовый оператор NOT для проверки EOF: while(~(c=getchar()))или while(c=getchar()+1)и изменяйте значение c в каждом месте

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

Возьмите следующий пример:

if (t()) a = b, b = 0;  /* 15 chars */

Обычная игра в гольф подход заключается в замене ifс &&, но из-за низкого приоритета оператора запятая, вам требуется дополнительная пара скобок:

t() && (a = b, b = 0);  /* still 15 chars */

Средняя часть троичного оператора не нуждается в скобках:

t() ? a = b, b = 0 : 0;  /* 14 chars */

Подобные комментарии относятся к подпискам массива.

Любая часть вашего кода, которая повторяется несколько раз, является кандидатом на замену препроцессором.

#define R return

Это очень распространенный случай использования, если ваш код включает в себя более пары функций. Другие длинноватые ключевые слова , такие как while, double, switch, и caseтакже являются кандидатами; а также все, что является сомнительным в вашем коде.

Я обычно резервирую заглавные буквы для этой цели.

Если ваша программа читает или пишет по одному на каждом шаге, всегда старайтесь использовать функцию чтения и записи вместо getchar () и putchar () .

Пример ( поменять стандартный ввод и поместить на стандартный вывод )

main(_){write(read(0,&_,1)&&main());}

Упражнение: Используйте эту технику, чтобы получить хороший результат здесь .

Обратные петли

Если можешь, попробуй заменить

for(int i=0;i<n;i++){...}

с участием

for(int i=n;i--;){...}

Если вам когда-либо понадобится вывести один символ новой строки ( \n), не используйте putchar(10), используйте puts("").

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

Примеры:

close(fd);foo=0;   →  foo=close(fd);    /* saves two bytes */
putchar(c);bar=0;  →  bar=!putchar(c);  /* saves one byte  */

Назначьте вместо возврата.

Это не совсем стандартный C, но он работает с каждым известным мне компилятором и процессором:

int sqr(int a){return a*a;}

имеет такой же эффект как:

int sqr(int a){a*=a;}

Потому что первый аргумент сохраняется в том же регистре процессора, что и возвращаемое значение.

Примечание. Как отмечается в одном комментарии, это неопределенное поведение, которое не гарантируется для каждой операции. И любая оптимизация компилятора просто пропустит это.

X-макросы

Еще одна полезная функция: X-Macros могут помочь вам, когда у вас есть список переменных, и вам нужно выполнить некоторые операции, которые включают все из них:

https://en.wikipedia.org/wiki/X_Macro

1. Используйте *aвместо a[0]доступа к первому элементу массива.

2. Реляционные операторы ( !=, >и т. Д.) Дают 0или 1. Используйте это с арифметическими операторами, чтобы задать различные смещения в зависимости от того, является ли условие истинным или ложным: a[1+2*(i<3)]получит доступ, a[1]если i >= 3и в a[3]противном случае.

Вы можете заглянуть в архив IOCCC (международный конкурс обфусцированного кода C).

Один заметный трюк заключается в том, чтобы #define макросы, чье расширение имеет несбалансированные скобки / скобки, например

#define P printf(

for(int i=0;i<n;i++){a(i);b(i);} короче можно сделать несколькими способами:

for(int i=0;i<n;){a(i);b(i++);} -1 для перемещения ++до последнего iв цикле

for(int i=0;i<n;b(i++))a(i); -3 больше для перемещения всех операторов, кроме одного, в верхнюю часть и из основного цикла, удаления скобок

Работай!

Если вы можете свести свою проблему к простым функциям с такой же сигнатурой и определенным как одиночные выражения, то вы можете добиться большего успеха #define r returnи вычленить практически весь шаблон для определения функции.

#define D(f,...)f(x){return __VA_ARGS__;}
D(f,x+2)
D(g,4*x-4)
D(main,g(4))

Результатом программы является ее значение состояния, возвращаемое ОС или управляющей оболочке или IDE.

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

#define D(f,b)f(x){return b;}

1. используйте, scanf("%*d ");чтобы прочитать фиктивный ввод. (в случае, если ввод не имеет смысла в дальнейшей программе), он короче, чем scanf("%d",&t);где вы также должны объявить переменную t.

2. Хранение символов в массиве int намного лучше, чем в массиве символов. пример.

   s[],t;main(c){for(scanf("%*d ");~(c=getchar());s[t++]=c)putchar(s[t]);}

Выведите символ, затем возврат каретки вместо:

printf("%c\n",c);

или же

putchar(c);putchar('\n'); // or its ascii value, whatever!

просто объявите c как int и:

puts(&c);

Использование asprintf()спасает вас от явного размещения, а также измерения длины строки ака char*! Возможно, это не слишком полезно для игры в код, но облегчает повседневную работу с массивами символов. Есть еще несколько хороших советов в 21 веке .

Пример использования:

#define _GNU_SOURCE
#include <stdio.h>

int main(int argc, char** argv) {
  char* foo;
  asprintf(&foo, "%s", argv[1]);
  printf("%s",foo);
}

import если вам нужно

Как отмечалось в самом первом ответе , некоторые компиляторы (в частности, GCC и clang) позволяют вам не использовать #includes для стандартных функций библиотеки.

Даже если вы не можете просто удалить #include, могут быть другие способы избежать этого , но это не всегда практично или особенно в гольфе.

В остальных случаях вы можете использовать #import<header file>вместо того, #include<header file>чтобы сохранить байт. Это расширение GNU, и оно считается устаревшим, но оно работает по крайней мере в gcc 4.8, gcc 5.1 и clang 3.7.

Попробуй cpow()вместоcos()

Вместо

double y=cos(M_PI*2*x);

попробуй что-то вроде

double y=cpow(-1,x*2);

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

$\cos 2\pi x+j\sin 2\pi x=e^{j2\pi x}=e^{j\pi 2x}=\left(-1\right)^{2x}$

Этот тип трюк может быть использован для уменьшения

double y=cpow(-1,x/2);

в

double y=cpow(1i,x);

$\left(-1\right)^\frac{x}{2}=j^\frac{2x}{2}=j^x$

$\LaTeX$

Вот несколько советов, которые я использовал в своих интересах. Я бесстыдно украл их у других, так что поверь никому, кроме меня:

Объединить назначение с вызовами функций

Вместо этого:

r = /* Some random expression */
printf("%d", r);

Сделай это:

printf("%d", r = /* Some random expression */);

Инициализируйте несколько переменных вместе (когда это возможно)

Вместо этого:

for(i=0,j=0;...;...){ /* ... */ }

Сделай это:

for(i=j=0;...;...){ /* ... */ }

Свернуть ноль / ненулевые значения

Это аккуратный трюк, который я подобрал у кого-то здесь (не помню, кто, извините). Если у вас есть целочисленное значение, и вам нужно свернуть его до 1 или 0, вы можете использовать !!это легко. Это иногда выгодно для других альтернатив, как ?:.

Возьмите эту ситуацию:

n=2*n+isupper(s[j])?1:0; /* 24 */

Вы могли бы вместо этого сделать это:

n=n*2+!!isupper(s[j]); /* 22 */

Другой пример:

r=R+(memcmp(b+6,"---",3)?R:0); /* 30 */

Может быть переписан как:

r=R+R*!!memcmp(b+6,"---",3)); /* 29 */

Знание основных логических равенств может сэкономить пару байтов. Например, вместо того, чтобы if (!(a&&b)){}пытаться вместо этого использовать закон Деморгана if (!a||!b){}. То же самое относится к побитовым функциям: вместо ~(a|b)do ~a&~b.