Каковы некоторые известные однострочные или двухстрочные программы и уравнения? [закрыто]

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

Например,

#include<stdio.h>
int main(){printf ("Hi World\n");return 0;}

60 символов точно!

Большое спасибо за вашу мудрость!

Классическая процедура копирования C-строк известна все меньше и меньше людей в эти дни:

while (*d++ = *s++);

не одну строчку, но я представляю последнюю в мире ошибку C:

    status = GetRadarInfo();
    if (status = 1)
      LaunchNukes();

Я вижу игру жизни Конвея в APL, которая витает вокруг:

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

Модифицированная версия знаменитой однострочной версии Perl:

/^.?$|^(..+?)\1+$/

Это регулярное выражение соответствует строкам, длина которых проста.

Оригинальная версия:

/^1?$|^(11+?)\1+$/

который соответствует строки, состоящие из простого числа 1 с.

Quicksort:

qsort []     = []
qsort (x:xs) = qsort (filter (< x) xs) ++ [x] ++ qsort (filter (>= x) xs)

Если список пуст, отсортированный результат - пустой список.

Если список начинается с элемента x, а остальная часть списка - xs, то отсортированным результатом является список, состоящий из отсортированного списка, состоящего из всех элементов в xs меньше x, сцепленных с элементом x, сцепленным с отсортированным списком всех элементы в хз больше, чем х.

(или другими словами - разделите на две кучи, все меньше чем x и все больше, чем x, отсортируйте их обе и создайте список с кучей меньше, элементом x и кучей больше).

Бьет понятность версии C довольно легко.

1. Функция Аккермана . Реализация версии Аккермана-Петера должна вписаться в 60 символов :)

2. Эта прекрасная шестнадцатеричная константа: 0x5f3759df. Это сердце самого кода WTFing, который я когда-либо видел: быстрый обратный квадратный корень .

3. Знаменитый своп XOR .

4. question = /(bb|[^b]{2})/

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

:(){ :|:& };:

print "hello world\n";

и его происхождение, кажется, популярно. :-)

Поскольку вы упоминаете уравнения, это принадлежит вашему списку:

e^{i\pi}+1=0

( Wolfram Alpha рендеринг : )

Как определить четные числа:

x % 2 == 0

import this в Python.

РЕДАКТИРОВАТЬ, поскольку комментарии не могут содержать разрывы строк: для тех, у кого нет удобного интерпретатора Python, это вывод

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Не совсем 2 строки, но я бы сказал, что это довольно известный:

void swap(float* x, float* y)
{
    float t;
    t = *x;
    *x = *y;
    *y = t;
}

На самом деле некоторые языки могут описать это в одной строке. Луа приходит на ум, но есть и другие.

x, y = y, x

Мой любимый пример лямбда-исчисления - комбинатор Y:

Y = λf.(λx.f (x x)) (λx.f (x x))

Из упражнения в K & R, вот функция, которая будет возвращать, сколько битов установлено в данном числе. На 58 символов:

int bits(int n){int b=0;while(n){n=n&(n-1);b++;}return b;}

Это занимает время, пропорциональное количеству установленных бит. Часть "ах ха" здесь заключается в том, что

n = n & (n - 1)

Удаляет самый правый установленный бит из n.

Треугольник рекурсивного Паскаля в одной строке (Haskell)

  r n=take(n+1)$iterate(\a->zipWith(+)(0:a)$a++[0])[1]

Пятьдесят два символа, добавьте пробелы по вкусу. Предоставлено «Эфимент» в комментарии здесь .

Я подумал, что это лучший пример, чем загадочные, но краткие решения в J и K (хотя я пока не пользователь Haskell).

Unix рулетка (ОПАСНОСТЬ!)

Предоставлено ответом Bigown в ветке шутки (и комментарий):

[ $[ $RANDOM % 6 ] == 0 ] && rm -rf /* || echo Click #Roulette

(Это 62 символа в длину, так что вы можете удалить комментарий (так будет работать?) Или некоторые ненужные пробелы.)

Бесконечная последовательность Фибоначчи (Хаскелл)

fibs = 0 : 1 : zipWith (+) fibs (tail fibs)

DO 10 I=1.3

Это одна из самых дорогих ошибок в истории. Этот оператор Fortran назначает значение с плавающей запятой равным 1,3 названной переменной DO10I.

Правильный код - заголовок повторяющихся операторов цикла, пока оператор не помечен как 10, а переменная цикла не Iпринимает значения 1, 2, 3:

DO 10 I=1,3

Устройство Даффа :

void send(short *to, short *from, int count)
{
    int n = (count +7 ) / 8;

    switch (count % 8) {
    case 0: do {    *to = *from++;
    case 7:         *to = *from++;
    case 6:         *to = *from++;
    case 5:         *to = *from++;
    case 4:         *to = *from++;
    case 3:         *to = *from++;
    case 2:         *to = *from++;
    case 1:         *to = *from++;
        } while(--n > 0);
    }
}

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

Все, что связано с Hello World, приходит на ум. Вы можете использовать разные варианты, если планируете хранить несколько языков.

Для чего-то более нетривиального есть Фиббоначи .

val (minors, adults) = people.partition(_.age < 18)

Приведенная выше строка кода Scala разбивает people(список Person) на два списка в зависимости от их возраста.

Чтобы сделать то же самое в Java, требуется большая часть кода:

List<Person> minors = new ArrayList<Person>();
List<Person> adults = new ArrayList<Person>();
for(Person p : people) {
  if(p.age < 18) {
    minors.add(p);
  } else {
    adults.add(p);
  }
}

Обмен значениями двух переменных без использования третьей переменной. Это одна из первых вещей в программировании, что мне сказали и подумали: «Хм ... это круто»

int a,b; 
b=a-b;
a=a-b;
b=a+b;

Черная магия от Джона Кармака

float Q_rsqrt( float number )
{
    long i;
    float x2, y;
    const float threehalfs = 1.5F;

    x2 = number * 0.5F;
    y  = number;
    i  = * ( long * ) &y;                       // evil floating point bit level hacking
    i  = 0x5f3759df - ( i >> 1 );               // what the ****?
    y  = * ( float * ) &i;
    y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration
//  y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed

    return y;
}

Наибольшее число, которое может быть представлено 8 байт (Python)

print '\n'.join("%i Byte = %i Bit = largest number: %i" % (j, j*8, 256**j-1) for j in (1 << i for i in xrange(8)))

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

   minVal = (a <b)? а: б;

2. Переключатель чехол

3. цикл for-each [Java]

это Куайн из файла Jargon в C:

символ * F = "символ * F =% C% S% с; основными () {Е (е, 34, F, 34,10);}% С"; основными () {Е (е, 34, F, 34,10);}

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

личность Эйлера, которая связывает самые красивые числа в математической вселенной: 1, 0, e, i и π: e ^ i (π) + 1 = 0

У меня был хороший, и я записал это на полях.

int gcd(int a, int b)
{
   while(b>0)
   {
      int t = a%b;
      a=b;
      b=t;
   }
   return a;
}

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

Это чуть более 60 символов, но это действительно зависит от именования переменных (так что я включаю это!)

позвольте readLines (rdr: StreamReader) =
      seq {пока не rdr.EndOfStream действительно
                приводят к rdr.ReadLine ()}

Хорошая маленькая функция для чтения файла в последовательность строка за строкой в ​​F #.