Задачи

Все участники пытаются решить следующий список из 10 задач:

математический

1. Считайте положительное целое число n из входных данных и верните сумму кубов первых n неотрицательных целых чисел.

   Для ввода 1это должно вернуться 0.

2. Считайте положительное целое число n из входных данных и верните истинное значение тогда и только тогда, когда n - простое число Мерсенна .

3. Прочитайте непустой список из n целых чисел и введите их медиану .

   Если n четное, используйте меньшее из двух средних значений.

   Например, медиана [1 4 3 2]это 2.

4. Считать целое число (положительное, отрицательное или 0) или строковое представление в базе 10 или унарное из входных данных и вернуть их цифры в неабинарном виде без начальных нулей (за исключением ввода 0).

   Вывод может быть отформатирован любым удобным способом (цифры, массив, строка и т. Д.).

строка

5. Возвращение pneumonoultramicroscopicsilicovolcanoconiosis.

6. Проверьте текущую дату и Happy New Year!при необходимости верните в соответствии с григорианским календарем.

7. Псевдослучайно выбирает 64 уникальных назначенных кодовых точки из блока Unicode CJK Unified Ideographs Extension-A (U + 3400 - U + 4DB5) и возвращает строку соответствующих символов.

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

8. Считайте две строки печатных символов ASCII из ввода и верните истинное значение тогда и только тогда, когда символ первой строки образует подпоследовательность второй строки.

   Например, abc, axbxcдолжен возвращать truthy и bac, axbxcдолжен вернуться falsy.

массив манипуляции

9. Считайте многомерный прямоугольный массив целых чисел и целое число n из входных данных и верните измененный массив со всеми целыми числами, умноженными на n .

ASCII-арт

10. Считайте неотрицательное целое число n из входных данных и верните цепочку из n железнодорожных вагонов, как показано ниже.

    Пример вывода для n = 3 :

     ______   ______   ______ 
    |      | |      | |      |
     ()--() ~ ()--() ~ ()--()
    

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

Разъяснения

• 0 не является ни положительным, ни отрицательным.

• Конечный пробел всегда разрешен в выходных данных.

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

правила

1. Ни один ответ не может решить две разные задачи на одном языке программирования. ¹

2. Для каждого отдельного задания применяются стандартные правила игры в гольф .

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

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

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

   Пожалуйста, отформатируйте ваш ответ как в следующем примере:

   ## Task 1, Python, 42 bytes
   
       <code goes here>
   
   Explanation, I/O, required Python version, etc. go here.
   
   ---
   
   ## Task 7, C, 42 bytes
   
       <code goes here>
   
   Explanation, I/O, required compiler (flags), etc. go here.
   

счет

1. За каждую решаемую задачу вы получаете одно очко.

   Это означает, что вам не нужно решать все задачи для участия.

2. Если ваше решение для задачи n является самым коротким на этом языке программирования, вы получаете дополнительное очко.

3. Если ваше решение для задачи n является самым коротким из всех языков программирования, вы получаете дополнительное очко.

4. Бонусные баллы будут начисляться только один раз за каждую комбинацию языка задачи и каждого задания соответственно.

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

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

5. Вы можете подать заявку в гольф, добавить / удалить языки из своего ответа или поменять языки, используемые для двух задач.

   Каждый раз, когда кто-то редактирует свой ответ, все ответы сохраняются.

6. После того, как вы смените язык для задания, вы потеряете трудовой стаж. ²

Ответ с наибольшим количеством очков выигрывает. ³

Таблица лидеров для каждой задачи

<style>body{text-align:left!important}#answer-list{padding:10px;width:290px;float:left}#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}</style><script src=https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js></script><link rel=stylesheet href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id=answer-list><table class=answer-list><thead><tr><td>Task<td>Author<td>Language<td>Score<tbody id=answers></table></div><table style=display:none><tbody id=answer-template><tr><td>{{TASK}}<td>{{NAME}}<td>{{LANGUAGE}}<td>{{SIZE}}</table><script>function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),e.has_more?getAnswers():process()}})}function process(){answers.forEach(function(e){var s=e.body_markdown.split("\n").filter(function(e){return"#"==e[0]});s.forEach(function(s){var r=s.match(NUMBER_REG)[0],t=(s.match(SIZE_REG)||[0])[0],a=s.match(LANGUAGE_REG)[1],n=e.owner.display_name;entries.push({task:r,user:n,language:a,size:t})})}),entries.sort(function(e,s){var r=e.task-s.task;return r?r:e.size-s.size});for(var e=0;e<entries.length;e++){var s=jQuery("#answer-template").html();s=s.replace("{{TASK}}",entries[e].task).replace("{{NAME}}",entries[e].user).replace("{{LANGUAGE}}",entries[e].language).replace("{{SIZE}}",entries[e].size),s=jQuery(s),jQuery("#answers").append(s)}}var QUESTION_ID=52152,ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*$)/,NUMBER_REG=/\d+/,LANGUAGE_REG=/^#*.*?,\s*\[*([^,\]]+)/,entries=[];</script>

Комбинированный список лидеров (2015-07-30 20:00 UTC)

User / Task      1 2 3 4 5 6 7 8 9 A   TOTAL   Tie breaker (if any)

DLosc            2 2 3 2 2 2 2 3 2 2      22
Sp3000           2 2 2 2 2 3 2 2 2 2      21
Doorknob         2 2 2 2 2 2 2 2 2 2      20
mathmandan       2 2 2 2 2 2 2 2 2 2      20   Combined byte count.
MickyT           2 2 2 2 2 2 1 2 2 2      19
Alex A.          2 1 2 2 2 2 1 2 2 2      18
Jacob            2 2 2 2 2 1 0 0 0 2      13
alephalpha       2 2 2 0 2 2 0 0 2 0      12
Martin Büttner   2 0 0 2 2 0 0 2 2 2      12   Combined byte count.
kirbyfan64sos    1 2 2 0 2 X 0 2 0 3      12   Per-language wins.
Maltysen         3 0 0 0 3 2 1 X 2 0      11
plannapus        2 2 0 0 2 2 0 2 0 2      10
jimmy23013       0 0 2 3 0 0 3 2 0 0      10   Solved tasks.
Tom              0 3 0 0 2 2 0 X 3 0      10   Combined byte count.
FryAmTheEggman   1 0 2 0 2 0 2 0 2 0       9
Vioz-            1 0 2 2 2 2 0 0 0 0       9   Combined byte count.
Toby Speight     2 0 0 0 2 2 0 0 0 2       8
Ismael Miguel    0 0 0 0 2 2 0 0 0 2       6
Pulga            0 2 2 0 0 0 0 0 0 2       6   Combined byte count.
flawr            2 0 2 0 0 0 0 0 0 0       4     
manatwork        2 0 0 0 0 2 0 0 0 0       4   Combined byte count.
TheNumberOne     1 0 0 0 2 0 0 0 0 0       3

Задачи, отмеченные значком X, присутствуют, но недействительны.

Комбинированный список лидеров был построен вручную. Пожалуйста, сообщите мне, если есть какие-либо ошибки.

¹ _{Языки считаются разными, если они не являются разными версиями одного и того же языка, поэтому есть только один JavaScript, один Python и один TI-BASIC, но C, C ++, Octave и MATLAB - это четыре разных языка.}

² _{Если вы решаете задачу n, используя язык L в x байтах, кто-то другой решает ту же задачу на том же языке с тем же количеством байтов, вы переходите на язык M и откатываете свои изменения, а другой отвечающий сохраняет бонусное очко.}

³ _{Количество баллов, полученных за счет правил 1, 2 и 3 (в указанном порядке), объединенное количество байтов всех выполненных задач (чем ниже, тем лучше) и, наконец, подсчет голосов (чем выше, тем лучше) служат в качестве брейкбрейков.}

Задача 1, GolfScript, 8 байт

~,{+}*.*

Та же идея, что и у CJam- ответа Мартина .

Задача 2, QBasic, 74 71 байт

INPUT a
r=a>1
FOR i=2 TO a-1
r=r*(a MOD i)
NEXT
?r*((a\2AND a)=a\2)

Протестировано на QB64 с выключенным расширением синтаксиса. ¹ Основная часть программы проверяет, является ли данное число aпростым, беря amod каждое число 2 <= i< aи умножая результаты. Результат равен r0, если число не простое, и ненулевое в противном случае. Последняя строка использует побитовое ANDс целочисленным делением на 2, чтобы проверить, является ли двоичное представление aвсех единицей, то есть aимеет форму 2 ⁿ -1. Умножение на это rдает 0 (ложь), если число не является простым числом Мерсенна, а в противном случае - ненулевое (истинное) значение. ?это ярлык для PRINT.

Самый большой из протестированных мною Мерсенна, 8191, дает результат - 1.#INFкоторый все еще правдив! (Я проверил с IFзаявлением, чтобы убедиться.)

¹ _{Это не меняет семантику программы. Если вы введете приведенный выше код в стандартную версию DOS QBasic, он будет автоматически отформатирован с дополнительными пробелами, но будет работать точно так же.}

Задача 3, Pyth, 6 байт

ehc2SQ

Читает список в стиле Python из стандартного ввода. Основное волшебство здесь - cоператор перехода: при наличии int и списка он разбивает список на n частей. Таким образом c2SQразбивает отсортированный входной список пополам. Удобно, когда длина нечетная, первая половина больше, поэтому медиана всегда является последним элементом первой половины. Это eй из hEAD результатов отбивной.

Задача 4, CJam, 26 байт

ri{_2%z\_0>\-2/_3$+?}h;]W%

Это может быть сокращено, я подозреваю.

Алгоритм:

• Читайте целое число.
• Делать, пока значение не равно 0:
  • Возьмите пресс (я% 2). Это следующая цифра (негабит?).
  • Разделите меня на -2.
  • Если бы я не был положительным, добавьте abs (i% 2) к результату. Это исправляет угловой случай: 3 идет к -1, но -3 должно идти к 2, а не 1.
• Бросьте лишние 0, соберите стопку в массив, переверните и напечатайте.

Тот факт, что это цикл do-while, учитывает случай 0.

Задача 5, Bash, 50 байтов

echo pneumonoultramicroscopicsilicovolcanoconiosis

Не так много, чтобы объяснить.

Задача 6, Python, 78 байт

from datetime import*
d=date.today()
if d.day<2>d.month:print"Happy New Year!"

Требуется Python 2. Здесь очень удобно использовать операторы неравенства в цепочке Python.

Задача 7, ActionScript, 82 байта

x=""
while(x.length<64){c=chr(13312+random(6582));if(x.indexOf(c)<0)x+=c}
trace(x)

ActionScript является членом семейства ECMAScript. Этот код требует ActionScript 2 - гораздо лучше для кода гольф, потому что я использую устаревшие функции, как chrвместо версии 3 String.fromCharCode!

Вывод на панель консоли:

Задача 8, Пип, 9 19 байт

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

Fcab@>:o&:(b@?c)+1o

Github хранилище для Pip .

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

Объяснение:

                     Cmdline args -> a,b; o = 1 (implicit)
Fca                  For each character in a:
           b@?c      Find character's index in b (nil if not found)
          (    )+1   Add 1; all possible indices except nil are now truthy
       o&:           Logical AND with o
   b@>:              Slice b to everything at index o and afterward (Python b=b[o:])
                     (If c wasn't found, b becomes nil, but we don't care at that point)
                  o  Auto-print o

Задача 9, Пролог (SWI), 68 байт

m(L,N,R):-L=[H|T],m(H,N,I),m(T,N,U),R=[I|U];L=[],R=[];R is L*N.

Пролог, как правило, вообще не конкурентоспособен в коде, поэтому я очень доволен этим решением.

Определяет предикат m с входными параметрами Lдля списка, а также Nдля числа и выходного параметра R. Определение mтройной дизъюнкции:

• Если Lможет быть унифицированы с [H|T], это список, по крайней мере , один элемент в нем. Вызовите mрекурсивно в начало и конец этого списка, и снова объедините результаты в новый список, который объединен с R.
• Если Lмогут быть объединены с [], унифицировать Rс []а.
• В противном случае Lпредполагается число; L*Nрассчитывается и присваивается R.

Пример запуска с использованием swiplUbuntu:

dlosc@dlosc:~/golf$ swipl -qs arrayMult.prolog
?- m([1,2,3],5,R).
R = [5, 10, 15] .

?- m([[3,4],[5,6]],3,R).
R = [[9, 12], [15, 18]] .

?- m([[[1,2],[3,4]],[[5,6],[7,8]]],2,R).
R = [[[2, 4], [6, 8]], [[10, 12], [14, 16]]] .

Задача 10, C, 114 112 106 байт

#define F;printf("\n");for(i=0;i<c;i++)printf(
i;t(c){F" ______  ")F"|      | ")F" ()--() ~");putchar(8);}

Проверено gccна Ubuntu. Определяет функцию, tкоторая принимает целочисленный аргумент. Использует три forцикла для вывода, сильно сжатых из-за неправильного использования макросов. Использование символа возврата для удаления завершающего ~результата приводит к довольно странному пробелу, ноThe output may be surrounded by any amount of whitespace as long as it looks like in the example.

Пример прогона t(3):

dlosc@dlosc:~/golf$ ./a.out

 ______   ______   ______
|      | |      | |      |
 ()--() ~ ()--() ~ ()--() dlosc@dlosc:~/golf$

Huzzah, первым, чтобы выполнить все задачи! \ О /

Задача 1, Perl, 32 байта

$_=eval join"+",map$_**3,0..$_-1

+1 байт за -pфлаг. Комментарий: Perl странный .

Задача 2, CJam, 14 байтов

{_mp\)2mL_i=&}

Моя первая программа CJam!

Задача 3, GolfScript, 8 байт

~$.,(2/=

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

Задача 4, Python, 77 байт

def f(i,d=''):
 while i:i,r=i/-2,i%2;i+=r<0;r+=2*(r<0);d=`r`+d
 return d or 0

Спасибо @ mbomb007 за сокращение 24 (!) Байтов и @ Sp3000 за еще 11.

Задача 5, Java, 66 байт

String f(){return"pneumonoultramicroscopicsilicovolcanoconiosis";}

Скучно. Здесь вырубили многословный язык, чтобы позже освободить место для языков игроков в гольф.

Задача 6, Баш, 39 байт

((`date +%j`<2))&&echo Happy New Year\!

Спасибо @manatwork за то, что научили меня %j, сокращая 10 байт в процессе.

Задача 7, JavaScript, 148 байт

a=[];Array(65).join('x').replace(/./g,function(){while(a.push(s=String.fromCharCode(13312+Math.random()*6582))&&a.indexOf(s)==s.length-1);return s})

Создайте строку из 64 x-х, затем замените их все на функцию обратного вызова, которая возвращает случайный один из этих символов, если его еще нет в массиве используемых символов.

Задача 8, Rust, 130 байт

fn f(a:String,b:String)->bool{let mut c=b.chars();for x in a.chars(){match c.find(|&y|x==y){Some(_)=>(),None=>return false}};true}

Да, Руст очень плохо играет в гольф.

Задача 9, Страус, 18 байт

{:n;'`\d+`{~n*}X~}

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

Задача 10, Ruby, 58 байт

->n{([' ______  '*n,'|      | '*n,' ()--() ~'*n]*$/).chop}

"\n"на один символ длиннее, чем "{actual newline}"на один символ длиннее $/. Спасибо @ MartinBüttner за то, что он сбрил {неопределенное, но большое количество} байтов с помощью различных приемов черной магии.

Задача 1, 3var, 14 13 байт

'><k*>#aa/>sp

( Esolang вики-страница для 3var )

'                  R = n
 >                 A = n
  <k               B = n-1
    *              R = A*B = n(n-1)
     >             A = n(n-1)
      #aa          B = 2
         /         R = A/B = n(n-1)/2
          >s       A = (n(n-1)/2)^2
            p      Output A

Принимает ввод через кодовую точку, например, пробел равен 32.

К счастью, все операции, которые нам нужны для реализации формулы, n^2 (n-1)^2 / 4- это одиночные символы (уменьшение, умножение и возведение в квадрат), но для установки значения B2 требуется 3 байта (сброс-приращение-приращение).

Задача 2, Retina, 38 33 байта

^
1
^(..|.(..+)\2+|(.(..)+)\3*)$
<empty>

( Github хранилище для Retina )

Каждая строка идет в отдельном файле, но вы можете проверить вышеизложенное с -sфлагом (заменяя его <empty>ничем). Ввод должен быть одинарным с 1, например, 1111111для 7.

Вот что делает каждая подстановка регулярного выражения (заданная парой строк):

1. Прибавьте еще 1 вперед
2. Заменить что-нибудь из формы 2, 1 + compositeили not power of 2ничего.

Это добавляет дополнительные 1к простым числам Мерсенна, в то время как все остальные числа стираются.

Задача 3, Ракетка, 71 байт

#lang racket
(define(m x)(list-ref(sort x <)(quotient(-(length x)1)2)))

Лисп-подобные языки просто слишком многословны. Пример выполнения:

> (m `(1 3 4 2))
2

Задача 4,> <>, 31 байт

:?!v:2%:@-02-,
)?~\l1
!;n>l?

( Вики-страница Esolang для> <> )

Выше 28 байтов, и требует -vфлаг в интерпретаторе Python для еще 3 байта , например, выполнить как

$ py -3 fish.py negabinary.fish -v -137
10001011

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

Задача 5, Parentetic, 1448 1386 байт

((()()())(()()()())((()())((()(())()))((()(())(())())((()(()))(()(())())((()(()))((())())((()()(()))((())()()()()()()()())((())()()()()()()()()()()()())))))))((()()())(()()())((()())((()(())()))((()()()())((()(()))(()(())())((())()()()()()()()()()()())))))((()(()))((()()())((())()()()()))((()()())((())()()))((()()()())((())()()()()))((()()())((())()()()()()()()()()))((()()())((())()))((()()())((())()()()))((()()())((())()()))((()()())((())()()()))((()()())((())()()()()()()()()()))((()()())((())))((()()())((())()()()()()()()()))((()()())((())()()()()()()))((()()()())((())))((()()())((())()))((()()()())((())()()()()()()()()))((()()()())((())()()))((()()())((())()()()()()()))((()()())((())()()()))((()()())((())()()()()()()()))((()()()())((())()()))((()()())((())()()()))((()()())((())()()()()))((()()()())((())()()()()()()()()))((()()()())((())()()))((()()())((())()()()()()()()))((()()()())((())()()()()()()()()))((()()())((())))((()()()())((())()()()()()()()()))((()()()())((())()()))((()()())((())()()()))((()()())((())()()()()()()()()()()))((()()())((())()()()))((()()())((())))((()()()())((())()()))((()()()())((())))((()()())((())()()))((()()())((())()()()))((()()()())((())()()))((()()())((())()()()))((()()())((())()()))((()()()())((())()()()()()()()()))((()()())((())()()()))((()()())((())()()()()()()()))((()()()())((())()()()()()()()()))((()()())((())()()()()()()())))

( Github хранилище для Parenthetic )

У меня есть ответ CJam для этого, который короче самой строки, но я не могу использовать его, поэтому я решил пойти другим путем.

Python 3 генерирует код:

char97 = "((()()())(()()()())((()())((()(())()))((()(())(())())((()(()))(()(())())((()(()))((())())((()()(()))((())()()()()()()()())((())()()()()()()()()()()()())))))))"
char108 = "((()()())(()()())((()())((()(())()))((()()()())((()(()))(()(())())((())()()()()()()()()()()())))))"
open_str = "((()(()))"
close_str = ")"

target = "pneumonoultramicroscopicsilicovolcanoconiosis"
output = [char97, char108, open_str]

for c in target:
    if ord(c) >= 108:
        output.append("((()()())((())%s))"%("()"*(ord(c)-108)))
    else:
        output.append("((()()()())((())%s))"%("()"*(ord(c)-97)))

output.append(close_str)
print("".join(output))

Вот соответствующий Lisp-подобный код:

(define f (lambda (n) (char (+ n 97))))
(define g (lambda (n) (f (+ n 11))))

(+
   (g 4)  // p
   (g 2)  // n
   (f 4)  // e
   ...
)

Видимо было нормально переопределить define, назвав gкак ()(), что сэкономило много байтов.

Задача 6, CJam, 26 байт

XY]et1>>"Happy New Year!"*

Проверяет, что [month day]часть массива местного времени меньше, чем [1, 2].

Задача 7, Python, 73 байта

from random import*
print(*map(chr,sample(range(13312,19894),64)),sep="")

Просто простая реализация Python 3.

Задание 8, прелюдия, 46 41 байт

?(?)#(#)?(v-(#)?)10)!
      ^      1 # (0

( Вики-страница Esolang для Prelude )

Я думаю, что это работает - это, вероятно, все еще пригодно для игры в гольф, но я впервые делаю нетривиальный гольф в Prelude. Формат входного сигнала <needle>NUL<haystack>, где NULнаходится 0x00. Это лучше всего работает с NUMERIC_OUTPUT = Trueинтерпретатором Python, так как это сделает его выводимым 1или 0соответствующим образом.

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

• Это основано на стеке, так что вы можете сначала прочитать в игле, затем обработать стог сена по одному символу за раз, и
• Стек Prelude имеет бесконечное число 0 в нижней части, поэтому вам не нужно обрабатывать случай, когда в игле заканчиваются символы.

Это было бы еще лучше, если бы у Prelude был оператор NOT.

Вот разбивка:

?(?)#    Read input up to the NUL, discarding the NUL afterwards

(#)      Move the needle to the second voice, effectively reversing the stack
 ^

?(...?)  Read haystack

  v-     Compare top needle char with haystack char by subtraction

  (#)    If equal, pop the needle char
   1 #

10)!     Output 1 if the top needle char is 0 (bottom of stack), 0 otherwise
(0

(-5 байт благодаря @ MartinBüttner)

Задача 9, Mathematica, 4 байта

#2#&

Что-то вроде 2 {{0, 1}, {1, 0}}неявного умножения в Mathematica, так что это просто помещает аргументы рядом.

Как отмечают @MartinButtner и @alephalpha , 1##&это еще один 4-байтовый ответ. Смотрите первый для объяснения.

Задача 10, Rail, 246 237 байт

$'main'
 0/aima19-@
@------e<
         -(!!)()[ ][ ______ ]{f}[\n\]o()[ ][|      |]{f}[\n\]o()[~][ ()--() ]{f}#
$'f'                 #           #
 -(!x!)(!y!)(!!)()0g<  -(x)o()1g<  -(y)o()1s(y)(x){f}#
                     -/          -/

( Esolang вики-страница для Rail )

Я не мог упустить возможность выполнить связанное с поездом задание в Rail :). Пустое пространство выглядит вполне подходящим для игры в гольф, но с разветвлением, занимающим три линии, для уплотнения потребуется немного работы.

Вводом является целое число через STDIN, но должен быть EOF. Верхняя левая часть

 0/aima19-@
@------e<

является циклом atoi, который преобразует входные данные в целое число, но не в EOF (проверяется eинструкцией).

Функция fв трех последних строках принимает x, y, nи выводит время строки x n, разделенное символом y. Функция рекурсивная, с nуменьшением на единицу каждый раз, пока не станет нулевой. fвызывается три раза, предоставляя разные строки для каждого ряда. Как ни странно, Rail позволяет именам переменных быть пустыми, что экономит несколько байтов.

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

Задача 1, CJam, 7 байтов

q~,:+_*

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

Проверьте это здесь.

Задача 4, Деление, 173 88 78 69 68 байт

GitHub хранилище для деления.

 /@\O/S@+>\
^{ }[<X/ @/;
,\?/@\J^X\
'M~\$ $
UK/W%@]  /
D
?\{\/
0'A Y

Моя вторая довольно сложная программа Fission. :)

Формат ввода немного странный. Для поддержки отрицательных входов, первый символ , как ожидается , будет либо +или -указать знак. Значение байта второго символа является величиной входного значения (так как Fission не может изначально прочитать десятичные целые числа). Так что, если вы хотите, 111вы передадите его +oна STDIN. И если вы хотите, -56вы передаете это -8. Вместо +и -вы можете использовать любой символ с более низким или высоким символьным кодом, соответственно. Это может быть полезно , чтобы передать что - то вроде -n(что ваша echoмощь лакомства в качестве аргумента) , как, например, 0n.

Давайте посмотрим, как мы можем найти неабинарное представление положительного числа. Мы хотим вычислить число от младшего до наиболее значимого бита (мы поместим эти биты в стек и распечатаем их все в конце, чтобы получить их в правильном порядке). Первая цифра - это просто четность числа, и мы делим число на целое число, чтобы продолжить обработку. Следующая цифра теперь отрицательная (со значением -2), но следует отметить, что этот бит будет установлен всякий раз, когда 2-бит будет установлен в обычном двоичном числе. Единственная разница состоит в том, что нам нужно противостоять -2 с положительными более значащими цифрами. Итак, что мы делаем, это:

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

Значительное упрощение кода является результатом того, что он замечает, что условное добавление здесь эквивалентно округлению числа вверх при делении целого числа (если отброшенный бит был равен 1, мы увеличиваем результат деления на целое число на 1).

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

Как мы можем обращаться с отрицательными целыми числами? Проблема в том, что Fission не может на самом деле делать произвольную арифметику с отрицательными целыми числами, потому что массы всегда неотрицательны. Поэтому нужно было бы сделать что-то действительно сложное, например, работать с величиной и отслеживать знак где-то еще. Однако негабинарное представление отрицательного числа может быть вычислено на основе связанного положительного числа:

Если п является отрицательным, вычислить negabinary представление N / 2 (округляется до ) и добавить четность п .

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

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

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

 /@\
^{ }[
,\?/
'
U
D
?

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

     /S@+>\
    [<X/ @/
 \  @\J^X\
 M  $ $
 K  %@]  /

Это цикл, который вычисляет отдельные биты и передает правильную половину в следующую итерацию. Символы Sи Jиспользуются для создания копии правой половины на основе текущего знакового бита, Xs выполняет копирование. В >верхнем правом углу вычисляется фактический бит, который затем отправляется в стек Kдля последующего извлечения. Я думаю, что расположение в верхнем правом углу довольно изящно и определенно стоит изучить подробно, если вы заинтересованы в Fission.

Это %переключатель, который возвращает число обратно в цикл, если оно больше 0.

    O


 M~\
 K/W%

 \{\/
0'A Y

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

Задание 5, прелюдия, 219 179 96 байт

Страница Esolangs для Прелюдии.

Стек Фрагмент интерпретатора для Прелюдии.

29+129+716705-7607-05-4759+705-14129+05-18705-29+719+05-1507-19+39+449+767549+03-68(67+^+^+^++!)

Это началось как стандартная программа Prelude с фиксированным выходом и тремя голосами. Поговорив с Sp3000, я решил попробовать один голос. Оказалось, что это работало довольно хорошо, потому что намного проще использовать старые буквы. Затем Деннис дал мне несколько советов, и я нашел текущую версию: идея состоит в том, чтобы поместить все смещения от буквы hв стек одного голоса в обратном порядке, а затем просто печатать их по одному за раз в цикле. hвыбрано потому, что hв строке нет (что важно - в противном случае 0смещение завершит цикл) и потому, что оно минимизирует кодирование смещений с точки зрения двузначных и отрицательных смещений.

Кодировка смещения была сгенерирована с помощью этого скрипта CJam .

Задача 8, Mathematica, 28 байт

LongestCommonSequence@##==#&

Yay для встроенных модулей. (Именование Mathematica здесь немного странно ... LongestCommonSubsequenceнаходит самую длинную общую подстроку, но LongestCommonSequenceнаходит самую длинную общую подпоследовательность .)

Задача 9, J, 1 байт

*

То же самое, что APL и K отвечают, но кажется, что никто еще не взял J.

Задача 10, Retina, 67 60 байт

GitHub хранилище для Retina.

(.*).
 ______  $1<LF>|      | $1<LF> ()--() ~$1
+`(.{9})1
$1$1
~$
<empty>

Каждая строка идет в отдельном файле и <LF>должна быть заменена символом новой строки и <empty>должна быть пустым файлом. Вы также можете поместить все это в один файл и использовать эту -sопцию, но это пока не позволяет вставлять символы новой строки вместо <LF>. Вы можете подражать этому, делая что-то вроде

echo -n "111" | ./Retina -s train.ret | ./Retina -e "<LF>" -e "\n"

Как показывает вышеприведенный пример, ожидается, что ввод будет одинарным. Идея кода состоит в том, чтобы создать три копии унарного ввода (минус 1), каждая с копией соответствующей строки. Затем мы многократно дублируем последние девять символов перед символом 1до тех пор, пока все 1s не исчезнут, повторяя при необходимости строки. Наконец, мы удаляем посторонний трейлинг ~.

Я начну с пары, наверное. Первый раз в гольф.

Задача 1, Python, 38 21 байт

lambda n:(n*n-n)**2/4

Суммируйте список всех кубов до x. Изменено выражение благодаря xnor

Задача 2, TI-Basic 89, 244 байта

Func
If iPart(log(x+1)/log(2))=log(x+1)/log(2) Then
 Return log(x+1)/log(2)
Else
 Return 0
EndIf
EndFunc
Func
If isPrime(x)=false
 Return 0
If ipart(log(x+1)/log(2))=log(log(x+1)/log(2)) Then
 Return log(x+1)/log(2)
Else
 Return 0
EndIf
EndFunc

Не уверен на 100%, буду тестировать, когда найду новые батарейки для своего калькулятора. isPrime является встроенным, ipart является целочисленной частью (2.3 -> 2)

Задача 3, Perl, 45 34 байта

@n=sort{$a-$b}@ARGV;print$n[$#n/2]

perl file 1 2 3 4 -> 2. Сохранено пару байтов благодаря @nutki. Печатается вместо сохранения в переменную, затем печатается переменная.

Задание 4, Ruby, 43 40 байт

x=2863311530
p ((gets.to_i+x)^x).to_s(2)

По крайней мере, это работает в 1.9, не знаю, около 1.8. В двоичном коде '10' * 16 (или 2863311530) плюс число, xor с этим 10101010 ... является небинарным. Выводит строковое представление с кавычками (3 -> «111», а не 3 -> 111). Не могу найти математику, чтобы написать х меньше символов.

Задача 5, Malbolge, 682 354 байта

D'``_]>n<|49ixTfR@sbq<(^J\ljY!DVf#/yb`vu)(xwpunsrk1Rngfkd*hgfe^]#a`BA]\[TxRQVOTSLpJOHlL.DhHA@d>C<`#?>7<54X8165.R2r0/(L,%k)"F&}${zy?`_uts9Zvo5slkji/glkdcb(fed]b[!B^WVUyYXQ9UNrLKPIHl/.JCBGFE>bBA@"!7[;{z276/.R2r0)(-&J$j('~D${"y?w_utyxq7Xtmlkji/gf,MLbgf_dc\"`BA]\UyYXWP8NMLpPIHGLEiIHGF(>C<A@9]7<;:3W7w5.-210/(L,%k#('~}C{"y?`_uts9wpXn4rkpoh.lNMiha'eGF\[`_^W{h

Попробуйте онлайн здесь. Подумайте, насколько это коротко. Гольф столько, сколько я мог. Сохранено 300 байт, так где?

Задача 6, Баш, 62 50 40 байт

[ `date +%j`=1 ]&&echo 'Happy New Year!'

О% j узнал из другого поста.

Задача 10, Befunge-98, 121 байт

>&:>1-:" ____"v
   |,k8: '"__"<
   >a,$:>1-v
      > |
>' 8k,^ #
^|':k4 '|':<
v ',*25$<
>,:1-: ")(--)("v
^," ~"_@#,k6" "<

Изменен на befunge-98. Старый был Befunge-93, 227 157 147 байт. Использовал Fungi, написанный на Haskell для тестирования. Использовал «сделать несколько раз k» и добавить отдельные символы в стек с помощью «. У меня такое чувство, что его можно сыграть в гольф до 110 или меньше, но я уже потратил слишком много времени на это ...

Первое: техническая задача 6 НЕ считается; Я загрузил unc менее часа назад. Тем не менее, я почти загрузил его сегодня утром, но решил сначала написать тестовый набор. Идиот.

Так или иначе, здесь идет!

Обратите внимание, что большинство unc-объектов преднамеренно задом наперед, так что на &&самом деле означает ||, что некоторые операции выглядят странно (например, использование -для вычисления куба).

Задача 1, Haskell, 21 байт

f n=sum$map(^3)[0..n]

Задача 2, Hy, 135 байт

(import math)(fn[n](and(if(and(not(% n 2))(> n 2))false(all(genexpr(% n i)[i(->> n(math.sqrt)int inc(range 3))])))(->> n dec(& n)not)))

Задача 3, Дротик, 37 байт

Моя первая функция Дартс!

f(l){l.sort();return l[l.length~/2];}

Задача 5, INTERCAL, 1047 байт

DO ,1 <- #46
DO ,1SUB#1 <- #242
DO ,1SUB#2 <- #152
DO ,1SUB#3 <- #208
PLEASE DO ,1SUB#4 <- #248
DO ,1SUB#5 <- #248
DO ,1SUB#6 <- #192
PLEASE DO ,1SUB#7 <- #128
DO ,1SUB#8 <- #128
DO ,1SUB#9 <- #72
PLEASE DO ,1SUB#10 <- #120
DO ,1SUB#11 <- #8
DO ,1SUB#12 <- #224
PLEASE DO ,1SUB#13 <- #200
DO ,1SUB#14 <- #208
DO ,1SUB#15 <- #32
PLEASE DO ,1SUB#16 <- #208
DO ,1SUB#17 <- #120
DO ,1SUB#18 <- #88
PLEASE DO ,1SUB#19 <- #40
DO ,1SUB#20 <- #8
DO ,1SUB#21 <- #208
PLEASE DO ,1SUB#22 <- #232
DO ,1SUB#23 <- #120
DO ,1SUB#24 <- #208
PLEASE DO ,1SUB#25 <- #248
DO ,1SUB#26 <- #56
DO ,1SUB#27 <- #96
PLEASE DO ,1SUB#28 <- #160
DO ,1SUB#29 <- #208
DO ,1SUB#30 <- #208
PLEASE DO ,1SUB#31 <- #136
DO ,1SUB#32 <- #120
DO ,1SUB#33 <- #192
PLEASE DO ,1SUB#34 <- #112
DO ,1SUB#35 <- #64
DO ,1SUB#36 <- #16
PLEASE DO ,1SUB#37 <- #128
DO ,1SUB#38 <- #48
DO ,1SUB#39 <- #208
PLEASE DO ,1SUB#40 <- #128
DO ,1SUB#41 <- #224
DO ,1SUB#42 <- #160
PLEASE DO ,1SUB#43 <- #40
DO ,1SUB#44 <- #56
DO ,1SUB#45 <- #200
PLEASE DO ,1SUB#46 <- #126
PLEASE DO READ OUT ,1
DO GIVE UP

Задача 6, unc, 157 байт

!include>=fgQVb%U<=
!include>=gVZR%U<=
false lRNe[]<<gVZR_g t:=gVZR[5]:volatile gZ m:=-YbPNYgVZR[&t]:for[#m%gZ_Zba||m%gZ_ZQNl!=6]chgf[L'uNccl ARj LRNe#']:>>

Задача 8, RS, 42 байта

#
+#(.)(.*) .*?\1/\1#\2 
.*# .*$/1
[^1]+/0

Живая демоверсия.

Задача 10, Pyth, 46 байт

jb(j*d2m+\ *\_6Qjdm"|      |"Qj\~m" ()--() "Q)

Живая демоверсия.

Задача 1, APL, 7 байтов

+/3*⍨⍳⎕

Вы можете попробовать это онлайн, используя ngn / apl, хотя он будет работать с любой реализацией APL, которая по умолчанию имеет нулевое начало индекса.

Это кубизирует каждое целое число от 0 до input ( ⍳⎕) -1 путем commuting ( ⍨) аргументов оператора power ( *). Результирующий вектор уменьшается суммированием ( +/) и скаляр возвращается.

Задача 2, Юлия, 42 байта

n->(isprime(n)&&int(log2(n+1))==log2(n+1))

Это создает анонимную функцию, которая принимает в качестве входных данных целое число и возвращает логическое значение. Чтобы назвать его, дайте ему имя, например f=n->....

Сначала мы используем встроенную функцию Джулии, isprimeчтобы проверить, nпростое ли . Если это так, мы проверяем, что log2(n+1)это целое число. Если это так, nможно записать как 2^k-1для некоторых k, и, таким образом n, простое число Мерсенна.

Задача 3, ELI , 19 байт

{f:x[<x][~.0.5*#x]}

Это создает монаду, fкоторая возвращает медиану входного вектора.

Ungolfed + объяснение:

{f:         // Define a function f
 x[<x]      // Sort the input vector
 [          // Select the element at index...
 ~.0.5*#x   // ceiling of 0.5 * length(input)
]}

Примеры:

    f 1 2 3 4
2
    f ?.!20   // Apply f to 20 random integers in 1..20
4

Задача 4, Октава, 39 байт

@(n,x=2863311530)dec2bin(bitxor(n+x,x))

Это создает дескриптор функции, который принимает целое число в качестве входных данных и возвращает связанную неабинарную строку. Чтобы позвонить, дать ему имя, например f=@..., и запустить с feval(f, <input>).

Вы можете попробовать это онлайн .

Задача 5, CJam, 47 байт

"pneumonoultramicroscopicsilicovolcanoconiosis"

Строка просто печатается в STDOUT. Вы можете попробовать это онлайн, если вы чувствуете себя таким склонным.

Задача 6, Пакет Windows, 46 байт

if "%date:~4,5%"=="01/01" echo Happy New Year!

Переменная %date%содержит текущую дату в форме Thu 06/25/2015. Мы можем выбрать месяц и день, получая подстроку длиной 5 после пропуска первых 4 -х символов: %date:~4,5%. Оттуда мы просто проверим, наступит ли 1 января, и скажем, с новым годом, если это так.

Задача 7, Pyth, 26 байт

=Gr13312 19895FNU64pC.(.SG

Сначала мы назначаем Gдиапазон от 13312 до 19894 включительно. Затем мы выполняем цикл 64 раза, и на каждой итерации выполняем shuffle G( .SG), удаляем и возвращаем последний элемент ( .() и печатаем его символьное представление ( pC).

Вы можете попробовать это онлайн .

Задача 8, Ruby, 36 байт

def f(a,b)!b.tr("^"+a,"")[a].nil?end

Это определяет функцию, fкоторая принимает две строки aи bгде aнаходится строка для поиска b.

Все, кроме символов в a, удаляются из bиспользования, .tr()и мы проверяем, содержит ли результат aточно использование []. Он вернется, nilесли строка не найдена, поэтому мы можем получить логическое значение, используя !with .nil?.

Задача 9, R, 16 байт

function(x,n)n*x

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

Задача 10, Python 3, 92 байта

n=int(input())
l="\n"
w=" ()--() "
print(" ______  "*n+l+"|      | "*n+l+(w+"~")*(n-1)+w)

Довольно просто. Вы можете попробовать это онлайн .

Задача 1,> <>, 10 + 3 = 13 байт

::*-:*4,n;

Запустите это, используя официальный интерпретатор Python, используя -vфлаг (по стоимости 3 байта). Это возводит в квадрат количество (n - n*n)и делит на 4, что, конечно, эквивалентно квадрату (n*n - n)и делению на 4.

Задача 2, GAP, 63 62 байта

b:=function(m)return[2]=AsSet(Factors(m+1))and IsPrime(m);end;

(Сэкономил место, написав равенство наоборот.)

Задача 3, R, 43 39 байт

f=function(v)sort(v,d=T)[length(v)%/%2]

Спасибо Plannapus за хорошее улучшение!

Задача 4, Пит, 155 135 115 5 * 19 = 95 кодеков

Протестируйте с помощью этого онлайн-переводчика с размером коделя 13. Или используйте предпочитаемого переводчика - дайте мне знать, если у вас есть тот, который вам нравится!

Сделать вывод 0вместо пустой строки для ввода 0было неудобно. Я использовал if-then в начале, чтобы позаботиться об этом случае; затем цикл while для вычисления цифр в ненулевом случае и, наконец, еще один цикл while в конце для вывода цифр из стека.

Большое спасибо Sp3000 за некоторые очень полезные комментарии, которые помогли мне сохранить некоторые кодеки!

Задача 5, Lua, 52 байта

print"pneumonoultramicroscopicsilicovolcanoconiosis"

Вы можете попробовать это здесь .

Задача 6, LaTeX, 157 139 136 127 128 байт

\documentclass{book}\begin{document}\count1=\day\multiply\count1 by\month
\ifcase\count1\or Happy New Year!\else~\fi\end{document}

Если произведение дня и месяца есть 1, распечатайте сообщение; иначе ничего. (Новый год особенно удобен для этой конструкции: так как выход мы ищем это 1, нам нужно только одно orзаявление В. nЧТ orоператор определяет поведение для значения n.)

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

Моя оригинальная версия использовала calcпакет, который был намного удобнее, чем моя текущая версия. Что-то иметь в виду для «реальной жизни»!

Задача 7, Ruby, 62 байта

for r in Array(13312..19893).sample(64)
puts [r].pack('U*')end

Задача 8, JavaScript, 78 байт

h=function(l,m){u=1+m.indexOf(l[0]);return(!l||u&&h(l.substr(1),m.substr(u)))}

Рекурсивное решение, проверяющее, lявляется ли подстрока m. Если lпусто, то !lрезультаты trueи функция завершается. (В этом случае l[0]он не определен, но с JavaScript все в порядке.) В противном случае он ищет первый экземпляр l[0]in m. Если он не находит, то m.indexOf(l[0])приводит к -1и так uприводит к 0и функция завершается.

В противном случае он удаляет первую запись lи первые uзаписи mи продолжает проверку.

Задача 9, Python, 72 60 байт

def i(a,n):
 try:return[i(c,n)for c in a]
 except:return n*a

Развертывает до «самого низкого уровня», где aсписок больше не является просто целым числом, затем выполняет умножение.

Большое спасибо Деннису за то, что он спас мне 12 байтов!

Задача 10, Groovy, 81 байт

def j(n){(' ------  '*n+'\n'+'|      | '*n+'\n'+' ()--() ~'*n).substring(0,27*n)}

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

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

Спасибо Деннису за фантастический вызов!

Задача 1, Pyth, 5 байт

s^R3Q

Берет номер из стандартного ввода. Спасибо @Jakube за указание на бесполезное U.

Задача 6, JavaScript, 56 байт

if(Date().slice(4,10)=="Jan 01")alert("Happy New Year!")

Задача 7, CJam, 16 байтов

6581,mr64<'㐀f+

Создает диапазон, тасует, выбирает первые 64 и отображает добавление начального значения и преобразование в символ. 14 символов, 16 байтов.

Задача 8, Октава, 23 байта

@(x,y)intersect(x,y)==x

Определяет анонимную функцию.

Задача 5, PHP, 45 байт

pneumonoultramicroscopicsilicovolcanoconiosis

Без сжатия, просто печатает.

Задача 9, APL 1 байт

 ×

Так же, как ответ К

Задача 1, R, 21 19 байт

sum((1:scan()-1)^3)

Довольно просто. Ввод из STDIN.

Задача 2, Perl, 40 66 байт

$a=log(<>+1)/log(2)+1;print$a==int($a)&&(1x$a)!~/^1?$|^(11+?)\1+$/

Добавлена ​​простейшая проверка (регулярное выражение проверки простых чисел Abigails)

Задача 3, PARI / GP, 24 22 байта

m(v)=vecsort(v)[#v\2];

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

Задача 4, T-SQL, 235 байт

CREATE FUNCTION D(@ INT)RETURNS TABLE RETURN WITH R AS(SELECT @/-2+(IIF(@%-2<0,1,0))D,CAST(ABS(@%-2) AS VARCHAR(MAX))M UNION ALL SELECT D/-2+(IIF(D%-2<0,1,0)),CAST(ABS(D%-2)AS VARCHAR(MAX))+M FROM R WHERE D<>0)SELECT M FROM R WHERE D=0

Встроенная табличная функция с использованием рекурсивного CTE. Очень большой, но забавный.

Использовать

SELECT * FROM D(18)
M
------
10110

Задача 5, GAP, 48 байтов

"pneumonoultramicroscopicsilicovolcanoconiosis";

Задача 6, Excel, 51 48 байт

=IF(TEXT(NOW(),"md")="11","Happy New Year!","")

Спасибо @Bond за 3 байта.

Задача 7, Python 2.6, 98 93 85 байт

from random import*
l=range(13312,19893)
shuffle(l)
print ''.join(map(unichr,l[:64]))

Это первый раз, когда я пытался сделать что-нибудь в Python, так что может быть намного лучше. Спасибо @Dennis и @Jacob за отличные советы

Задача 8, TCL, 57 байт

proc m {a b} {string match [regsub -all (.) $a *\\1]* $b}

Позор, что удаление пробела убивает это

Задача 9, Пайк, 53 байта

mixed m(array(array(int))a,int n){return(a[*])[*]*n;}

Функция, которая возвращает умноженный массив

Задача 10, Powershell, 88 байт

Function t($n){Foreach($s in "  ______ "," |      |","~ ()--() "){($s*$n).Substring(1)}}

Функция Powershell. Я думаю, что могу немного его укоротить, но вот это сейчас.

И наконец закончено :)

Задача 2, J, 10 байт

1&p:*/@,#:

Добавляет логическое значение 0 или 1, если входное значение является простым для своего двоичного представления, а затем принимает произведение. Работает на текущей версии J.

Задача 5, HTML, 45 байт

pneumonoultramicroscopicsilicovolcanoconiosis

Задача 6, рыба, 53 байта

test 0101 = (date '+%d%m');and echo 'Happy New Year!'

На основании ответа Bash.

Задача 8, APL, 12 байт

{(⍳⍴⍺)≡⍋⍵⍳⍺}

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

Задача 9, К, 1 байт

*

Должно работать в любой версии. Арифметические операции распределяются по массивам.

Задача 1, Ruby, 40 байт

def f n;(0..n-1).inject{|a,b|a+b**3};end

Впервые написал что-нибудь на Ruby. Протестировано с ruby ​​1.8.7.

Задача 2, R, 50 байтов

n=scan();p=log(n+1,2);!p%%1&sum(!n%%2:n,!p%%2:p)<3

Вычисляет p, проверьте, является ли оно целым числом, и являются ли n и p простыми числами.

Задача 5, PostgreSQL, 54 байта

SELECT'pneumonoultramicroscopicsilicovolcanoconiosis';

Задача 6, Lua, 55 байт

print(os.date("%j")=="001" and "Happy New Year!" or "")

Задача 8, Python, 65 байт

import re;f=lambda s,S:bool(re.search(re.sub(r'(.)',r'\1.*',s),S))

Использование:

>>> import re;f=lambda s,S:bool(re.search(re.sub(r'(.)',r'\1.*',s),S))
>>> f('abc','axbxcx')
True
>>> f('bac','axbxcx')
False
>>> f('abc','axdxcx')
False
>>> f('abc','abc')
True

Задача 10, Юлия, 73 байта

f(n)=print(" ______  "^n*"\n"*"|      | "^n*"\n"*(" ()--() ~"^n)[1:9n-1])

Спасибо @AlexA. за сокращение этого кода! Пример выходов:

julia> f(0)




julia> f(1)
 ______  
|      | 
 ()--() 

julia> f(2)
 ______   ______  
|      | |      | 
 ()--() ~ ()--() 

julia> f(3)
 ______   ______   ______  
|      | |      | |      | 
 ()--() ~ ()--() ~ ()--() 

Задача 1, Haskell, 17 байт

f x=(x*(x-1)/2)^2

Задача 2, Mathematica, 30 байтов

PrimeQ@#&&Mod[Log2[#+1],1]==0&

Задача 3, JavaScript, 46 байт

function(x){return x.sort()[0|(x.length-1)/2]}

Задача 5, MATLAB, 47 байт

'pneumonoultramicroscopicsilicovolcanoconiosis'

Задача 6, Ruby, 56 байт

print Time.now.to_s[5,5]=="01-01"?"Happy New Year!":""

Задача 7, Python, 106 байт (с отступом \t)

from random import*
s=''
while len(s)<64:
    c=unichr(randint(0x3400,0x4DB5))
    if c not in s:
        s+=c
print s

Обратите внимание, что прямое использование list(set(s))здесь не работает, так как это приведет к неравномерному распределению вероятностей в пространстве всех возможных строк из-за переупорядочения элементов списка.

Задача 1, Haskell, 15 байт

f n=(n*n-n)^2/4

Задача 2, Юлия, 28 байт

n->(isprime(n)&&ispow2(n+1))

Задача 3, Октава, 30 байт

@(x)sort(x)(ceil(length(x)/2))

Задача 5, Яки , 45 байт

pneumonoultramicroscopicsilicovolcanoconiosis

Задача 6, Mathematica, 46 байтов

If[DateList[][[{2,3}]]=={1,1},Happy New Year!]

Задача 9, PARI / GP, 10 байтов

(n,a)->n*a

Задача 3, клип, 13 байт

gHk[tivt}l`sk

Другая версия:

gHkci`v``l`sk

`, Казалось, стоимость слишком много.

Задание 4, KSFTgolf, 16 байт

g:]2%:)-2/:;xgpc

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

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

2*02-ba'Z=;x

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

qi{_1&_@^-2/}h;]W%

Я попробовал Пип, Страус, Клип и Бурлеск, чтобы выяснить, есть ли esolang со встроенным негабинаром. Никто из них не работал. KSFTgolf б / уnumpy , который, казалось, имел некоторое странное поведение, когда база была отрицательной. Но это не легко заставить его работать с неположительными числами.

Задача 7, CJam, 15 байтов

'䶶,DAm<>mr64<

Задача 8, APL, 21 байт

∨/↑{⍺∧0,2∧/∨\⍵}/⌽⍞=↓⍞

Попробуйте онлайн.

Задача 2, x86 masm, 40 байт

C7 45 FC FF FF 07 00 B9 
00 00 00 00 B8 02 00 00 
00 D3 E0 3B 45 FC 7D 03 
41 EB F1 B8 02 00 00 00
D3 E0 48 3B 45 FC 75 13

(исключая заголовок, MessageBox и т. д. - только соответствующие байты)

include     \masm32\include\user32.inc  
includelib  \masm32\lib\user32.lib

.data
    ClassName   db "Mersenne Prime Found",0
.data?

.code
start proc
    LOCAL IsMersenne: DWORD
    mov IsMersenne, 524287 ; put number to test in this input
    mov ecx, 0
l00p:
    mov eax, 2
    shl eax, cl
    cmp eax, IsMersenne
    jge br3ak
    inc ecx
    jmp l00p
br3ak:
    mov eax,2                                                                                     
    shl eax, cl 
    dec eax
    cmp eax, IsMersenne                                                           
    jnz n0pr1me                                                              
    invoke MessageBox, 0, addr ClassName, addr ClassName, 40h
n0pr1me:
    ret
start endp
end start

Задача 3, C, 136 байт

#include<stdio.h> 
int C(void*A,void*B){return(*(int*)A-*(int*)B);} 
main(){int S=4;int A[]={3,1,2,4};qsort(A,S,4,C);printf("%i",A[((S&1)?S:S-1)/2]);}

Скомпилировать используя gcc -o Prime main.c

Задача 10, C ++, 478 байт

#include<stdio.h>
#include<string.h> 
#include<stdlib.h>
void D(int Z){int L=9,i,X=0;const char*A=" ______  ";const char*B="|      | ";const char* C = " ()--() ~ ";char*P=(char*)malloc(27*Z+5);for(i=0;i<Z-1;i++){if(!i){memcpy(P,A,L);X+=L;}memcpy(&P[X],A,L);X+=L;if(i==Z-2){memcpy(&P[X],"\n",1);X++;}}for(i=0;i<Z;i++){memcpy(&P[X],B,L);X+=L;if(i==Z-1){memcpy(&P[X],"\n",1);X++;}}for(i=0;i<Z;i++){memcpy(&P[X],C,L);X+=L;if(i==Z-1)P[X-1]='\0';}printf("%s\n",P);free(P);}
main(){D(15);}

Скомпилировать используя g++ -o Trucks main.cpp

C & C ++ можно сократить, но это добавит ошибку компилятора. Не знаю точных правил, поэтому я попытался оставить код без ошибок компилятора.

Задача 1, Python, 35 байт

lambda x:sum(_**3for _ in range(x))

Задача 3, CJam, 9 байт

q~$_,(2/=

Задача 4, JavaScript, 55 53 байта

function(n){s=0xAAAAAAAA;return((n+s)^s).toString(2)}

Задача 5, Pyth, 46 байт

"pneumonoultramicroscopicsilicovolcanoconiosis

Задача 6, C #, 65 байт

string c(){return DateTime.Now.DayOfYear<2?"Happy New Year!":"";}

Задача 1, JQ, 24 байта

[range(1;.)|.*.*.]|add+0

Задача 6, PostgreSQL, 54 байта

select'Happy New Year!'where'001'=to_char(now(),'DDD')

Задача 1, Cjam, 7 байтов

q~,:+_*

Редактировать: Просто заметил, что Мартин опубликовал это до меня. Я попробую что-нибудь еще ...

Задача 3, Python, 30 байт

lambda l:sorted(l)[~-len(l)/2]

Python 2.

Задача 5, ///, 45 байт

pneumonoultramicroscopicsilicovolcanoconiosis

/// просто повторяет что-то без каких-либо /символов.

Задача 7, Pyth, 19 байт

s>64.SmC+13312d6582

Программа. Пожалуйста, скажите мне, если я испортила математику. Попробуй здесь

Задача 9, Октава, 9 байт

@(a,n)a*n

Дескриптор анонимной функции. Octave автоматически делает это с помощью матрицы * scalar.

Я не нашел времени, чтобы попробовать их всех, но вот начало

Задача 1, постоянный ток, 8 байт

d1+*d*4/

Ввод и вывод на вершину стека, в соответствии с dcсоглашением.

Задача 5, Emacs Lisp, 46 байт

'pneumonoultramicroscopicsilicovolcanoconiosis

Нарушение правил:

grep 'pn.*v' /usr/*/*/brit*-large

Лучшее, что я мог сделать, распаковав сжатую форму, было 55 в Perl:

unpack("H45",'uïFVóÙ¤¼g°0Æö<¥le°°')=~y/0-9bdf/i-v/r

(непечатные символы, указанные выше, искажены SE, но поскольку это не мой ответ, я не исправляю это)

Задача 6, SQL, 54 байта

SELECT IF(now()LIKE'%-01-0_%','Happy New Year!','Hi');

Я считаю, что первая декада января - «подходящие» дни для этого приветствия, но вы можете приспособиться к вкусу. now() LIKEКонструкция работает короче извлекая изо дня в год с DATE_FORMAT(now(),'%j').

Задача 10, sed, 58 байт

s/./ ()--() ~/g;s/.$//;h;y/()-~/___ /;p;g;y/ ()-~/|    /;G

Вход в одинарный.

Задача 5, MarioGolf , 50 байтов

Это был язык, который я разработал в течение некоторого времени.

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

Y|<pneumonoultramicroscopicsilicovolcanoconiosis|O

Вы можете попробовать это онлайн на http://htmlpreview.github.io/?https://raw.githubusercontent.com/ismael-miguel/mariogolf/master/js/testpage.html#c:Y|<pneumonoultramicroscopicsilicovolcanoconiosis|O

В настоящее время разработка остановлена, а реализация не завершена.

Последний коммит был 13 марта 2015 года.

Задача 6, PHP, 37 байт

Это действительно легко и весело!

<?=date(jn)==11?'Happy New Year!':'';

Задача 10, Javascript, 121 пока

Да, не так много в гольфе ...

Но это делает работу!

console.log((' ______  '.repeat(i=prompt()))+'\n'+('|      | '.repeat(i))+'\n'+(' ()--() ~'.repeat(i).replace(/~$/,'')));

Попробуй:

//Required to show the console messages on the document
console._RELAY_TO_DOC = true;

console.log((' ______  '.repeat(i=prompt()))+'\n '+('|      | '.repeat(i))+'\n '+(' ()--() ~'.repeat(i).replace(/~$/,'')));

<script src="http://ismael-miguel.github.io/console-log-to-document/files/console.log.min.js"></script>

Код не будет хорошо отображаться в фрагменте стека из-за того, что он начинается с " вывода. Adicional пробелы были добавлены, чтобы компенсировать это.

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

Задача 1, CJam, 10 байтов

li,{3#}%:+

Попробуй здесь

Задача 5, Retina, 46 байт

<empty>
pneumonoultramicroscopicsilicovolcanoconiosis

Задача 1, октава, 15 байт

@(n)(n^2-n)^2/4

РЕДАКТИРОВАТЬ: Я думал, что я добавил это, но, кажется, я забыл сохранить: это использует тот факт, что sum(1^3+2^3+3^3+...+n^3) = sum(1+2+3+...+n)^2 = [n*(n+1)/2]^2

Задача 3, Javascript, 24 байта

x=>x.sort()[x.length>>1]

Хорошо, давайте сначала сделаем простые вещи:

Задача 5, ASP, 45 байт

pneumonoultramicroscopicsilicovolcanoconiosis

Задача 6, JavaScript, 46 байт

/an 01/.test(Date())&&alert("Happy New Year!")

Задача 1, VBA, 126 байт

Function f(n As Integer)
    Dim i As Integer
    For i = 0 To n - 1
        f = f + i ^ 3
        Next i
End Function

Я не имею понятия, как играть в гольф в VBA. Я не набрал ни одного пробела, VBA автоматически вставляет пробелы. =f(5)в ячейке в Excel отобразится 100.

Задача 2, Октава, 32 байта

@(n)isprime(n)&~mod(log2(n+1),1)

Задача 5, Golfscript, 47 байт

"pneumonoultramicroscopicsilicovolcanoconiosis"

Задача 9, MATLAB, 9 байтов

@(A,n)A*n

Ну, это начало ...