Первый код десятиборье в гольф [закрыто]

48

Задачи

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Разъяснения

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

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

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

правила

  1. Ни один ответ не может решить две разные задачи на одном языке программирования. 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. После того, как вы смените язык для задания, вы потеряете трудовой стаж. 2

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

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

<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, присутствуют, но недействительны.

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


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

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

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

Деннис
источник
6
Чтобы уточнить, эта задача ограничена тем, кто знает как минимум 10 языков? Я прошу ... друга ...
vijrox
2
@VijayRamamurthy: Вам не нужно решать все задачи, чтобы участвовать, поэтому, если вы решаете только одну задачу, вам нужно знать только один язык.
Алекс А.
2
@JoeZ .: У нас было несколько проблем с 9 лунками, но эти записи были забиты по объему байтов. Не то, чтобы мой результат был каким-либо образом связан с тем, как набрали очки десятиборья, но я хотел пояснить, что это другой тип задачи.
Деннис
4
@lolesque: Это было бы стандартным вызовом для игры в гольф. Все дело в том, чтобы использовать разные языки для каждой задачи.
Деннис
3
@NotthatCharles: я спросил Грегори, и он сказал 1 января.
Деннис

Ответы:

5

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

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

1 Это не меняет семантику программы. Если вы введете приведенный выше код в стандартную версию 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!

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

Задача 7 скриншот


Задача 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$
DLosc
источник
К сожалению, ваш код для задачи 8 идентифицируется a.cкак подпоследовательность abc.
Деннис
@Dennis Это является неудачным. (Хороший улов, хотя, спасибо.) Исправлено, при стоимости 10 байтов.
DLosc
17

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 за то, что он сбрил {неопределенное, но большое количество} байтов с помощью различных приемов черной магии.

Дверная ручка
источник
Задача 6 - $(…)`…`.
manatwork
@manatwork Спасибо, отредактировано.
Дверная ручка
Подумав еще раз (поглощение кофеина продолжается ...), почему этот длинный формат% D? [ `date +%j` = 001 ]Или даже ((`date +%j`<2)). (Предполагается date, что GNU поддерживает формат «% j день года (001..366)».)
manatwork
@ Manatwork О, очень мило. Еще раз спасибо, добавил в ответ.
Дверная ручка
Задача 4 может быть сокращена с помощью ((num + 0xAAAAAAAA) ^ 0xAAAAAAAA) alg.
Джейкоб
15

Задача 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)это единственный способ скопировать вершину стека.

Sp3000
источник
Если бы задание 2 было в rs, вы бы сэкономили 2 байта, и было бы всего 14 байт, чтобы взять числа вместо унарных. ;)
kirbyfan64sos
Когда я увидел ракетку, я подумал, что вы любите скобки; но в скобках ...
bunyaCloven
13

Задача 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 не исчезнут, повторяя при необходимости строки. Наконец, мы удаляем посторонний трейлинг ~.

Мартин Эндер
источник
10

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

Задача 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 или меньше, но я уже потратил слишком много времени на это ...

Иаков
источник
@ Денис, так как я не могу спросить о главном посте, я спрошу здесь. Введен ли разделенный пробелами ввод для задачи 3? Это не будет в [].
Джейкоб
Все, что соответствует вашим потребностям.
Денис
1
Вы можете сократить сумму кубов по формуле :lambda n:(n*n-n)**2/4
xnor
Вы можете использовать 0=fPart(expression) rather than iPart (выражение) = выражение` в своем базовом ответе TI-89.
lirtosiast
1
Я думаю, что этот аргумент не работает, когда речь идет о чем-то вроде Python 2/3. Например, `n` работает лучше, чем str (n) в 2, но не работает в 3. В данный момент я не могу вспомнить другие примеры, меня больше интересует игра в гольф, которая должна ответить больше: p
Джейкоб
9

Первое: техническая задача 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)

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

kirbyfan64sos
источник
@ Денис Ой! Исправлена!
kirbyfan64sos
1
Ну, я не знаю, unc, но я уверен, что вам не нужен один из !includes. Не совсем уверен, какой из них, хотя.
Деннис
@Dennis Первое включает stdio.h, второе есть time.h. Мне нужны оба.
kirbyfan64sos
Что uncиспользуется для компиляции кода C? GCC будет работать без проблем stdio.h. Не уверен насчет time.h.
Денис
У @Dennis unc нет установленного компилятора. Он просто выводит код C; Я должен скомпилировать это сам. Однако это имеет смысл; Я проверю это позже.
kirbyfan64sos
8

Задача 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)

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

Алекс А.
источник
Ответ APL не совсем 7 байтов, поскольку в верхних диапазонах есть три символа Юникода.
Том
6
@Tom: Каждый ответ может выбрать наиболее удобную кодировку. В кодовой странице APL один символ - один байт.
Денис
Вы можете попробовать это онлайн, если вы чувствуете себя таким склонным :-D
Луис Мендо
7

Задача 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 для строк, который объединяет строки с определенной «связующей строкой» (например, связи между вагонами). Но это стоило намного больше, чем сэкономило.

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

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

mathmandan
источник
except:return n*aсохраняет несколько байтов для задачи 9. Для задачи 1 я бы посчитал -vфлаг одним байтом.
Деннис
@Dennis Посмотри этот мета-пост . Хотя с помощью этого мета-сообщения вы, вероятно, можете заменить -vфлаг на i(хотя я думаю, что было бы хорошо, если бы обе версии были упомянуты, для облегчения тестирования).
Sp3000
@ Денис, большое спасибо за ваши умные улучшения!
Матмандан
1
3 байта правильно по мета пост выше (пространство, -, v). Я просто имел в виду, что у вас есть возможность принять ввод как кодовую точку через iинструкцию.
Sp3000
1
Кстати, для # 4 отрицательный модуль не так уж странен - ​​он просто меняется от языка к языку (например, Java делает это из памяти). Один из способов вывода всего стека может состоять в том, чтобы держать что-то на дне стека, которого, как вы знаете, не будет в выводе, и сохранять печатные символы, пока это не тот специальный символ. Также есть PietCreator .
Sp3000
6

Задача 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 байт

 ×

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

Maltysen
источник
@ Денис, я тоже этого не знаю - я просто гуглил на догадки и собирал этот ответ без тестирования :). Попробую сейчас проверить на эмуляторе.
Малтысен
@ Денис, ты прав, в среднем 2, сними это.
Малтысен
1
Что вы делаете с этим пространством в .slice(4, 10)?
LegionMammal978
@Dennis derrrp. извиняюсь.
Малтысен
1
Есть только одно сокращение месяца, которое заканчивается на «an», так что вы можете не указывать J при тестировании. (Это также будет значительно короче /an 01/.test(Date()).)
NinjaBearMonkey
6

Задача 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. Я думаю, что могу немного его укоротить, но вот это сейчас.

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

MickyT
источник
Вы можете сохранить 4 байта на задаче 6: =IF(TEXT(NOW(),"md")="11","Happy New Year!","").
Бонд
@Bond Спасибо за это
MickyT
Я тоже не знаю Python, но l[:63]должен работать и (13312,19894)короче шестнадцатеричных констант (и суммы).
Деннис
@Dennis Спасибо, попробую и
поменяю
@ Денис Я выбрал 19893 как высокое значение, потому что range(19892,0x4DB5+1)дал мне[19892, 19893]
MickyT
4

Задача 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 байт

*

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

Том
источник
Комментарии не для расширенного обсуждения; этот разговор был перенесен в чат .
Мартин Эндер
2
Ваш код для задачи 8 не работает для abc caxbxc.
jimmy23013
4

Задача 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)
 ______   ______   ______  
|      | |      | |      | 
 ()--() ~ ()--() ~ ()--() 
plannapus
источник
Для Задачи 2 вы можете использоватьlog2
MickyT
Я считаю 86 байтов в настоящее время для вашей задачи 10 Джулии. Но вы можете получить его до 81, используя лямбда-функцию (т.е. заменить f(n)=на n->) и изменив 1:(9*n-1)на просто 1:9n-1.
Алекс А.
Правильно я посчитал \n1 байтом по привычке.
plannapus
Вместо (" "*"_"^6*" ")^nэтого вы можете использовать " ______ "^n(аналогично для | |части). 70 байт: n->print(" ______ "^n*"\n"*"| | "^n*"\n"*(" ()--() ~"^n)[1:9n-1]). (Пробелы между столбцами здесь не отображаются)
Алекс А.
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))здесь не работает, так как это приведет к неравномерному распределению вероятностей в пространстве всех возможных строк из-за переупорядочения элементов списка.


Сарань
источник
@ Денис, повторное задание 7: Согласен по пункту 1, исправлю всякий раз, когда у меня будет шанс. Что касается REPL, есть ли правила против этого?
Саран
Хорошо, все исправлено.
Саран
Для 1, предположительно, вы можете сделать (x*x-x)^2/4?
xnor
Досадно, что функция сортировки по умолчанию JavaScript преобразует числа в строки при сравнении, поэтому сравнивает только первую цифру каждого числа. Таким образом, он терпит неудачу на [2,3,10].
NinjaBearMonkey
1
В 7 вы можете поместить if c not in s:s+=cвсе в одну строку, сохранив несколько символов. Также 0x3400может быть заменен на 13312, который на один символ короче (и аналогично для 0x4db5). Наконец, это не изменит количество символов, но в случае, если вам не нравится отступ на вкладке, вы можете сделать отступ с одним пробелом.
Матмандан
3

Задача 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
alephalpha
источник
3

Задача 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∧/∨\⍵}/⌽⍞=↓⍞

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

jimmy23013
источник
Lol @ «Я не уверен, что я делаю»
Алекс А.
Вопрос был не очень ясен по этому поводу, но я намеревался, чтобы код для задачи 4 обрабатывал ввод 0. Версия без встроенного базового преобразования, кажется, справляется с этим просто отлично.
Деннис
@ Денис Исправлено. Но что, если я решил использовать одинарный?
jimmy23013
Использование некоторого фиксированного смещения или дополнения 2 может сработать. Я также принял бы знак, сопровождаемый одинарным номером.
Деннис
3

Задача 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 ++ можно сократить, но это добавит ошибку компилятора. Не знаю точных правил, поэтому я попытался оставить код без ошибок компилятора.

Pulga
источник
3
Добро пожаловать в PPCG! Предупреждения компилятора можно безопасно игнорировать, если компилятор создает полезный двоичный файл.
Деннис
2
В коде гольф компилятор C предупредит вас о том, что его можно продолжить, не создавая предупреждения.
Коминтерн
Игнорировать предупреждения - и чувствовать, гм, свободный течь столько памяти , как вы хотите, тоже. :-)
Тоби Спейт
3

Задача 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!":"";}
Када
источник
2

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

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

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

select'Happy New Year!'where'001'=to_char(now(),'DDD')
manatwork
источник
2

Задача 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.

FryAmTheEggman
источник
Для задачи 7 она должна быть уникальной.
Малтысен
Да, у Pyth есть .Sshuffle, и вы можете использовать его sвместо jk.
Малтысен
2

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

Задача 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

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

Тоби Спейт
источник
strstrпоиск подстрок, а не подпоследовательностей. Боюсь, задача 5 сложна по колмогорову, поэтому выбор слова из словаря может быть умным, но это не разрешено.
Деннис
Благодарю. Я неправильно понял подпоследовательность один. Я сделаю альтернативное задание 5, но это очень скучно.
Тоби Спейт
У задачи 5 есть несколько интересных решений, но пока никто не опубликовал короткое .
Деннис
1

Задача 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(/~$/,'')));

Попробуй:

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

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

Исмаэль Мигель
источник
@ Денис Спасибо! Я неправильно прочитал задачу 5. Я все еще смотрю, как я буду выполнять другие задачи, но у меня плохое время.
Исмаэль Мигель
1
Вы уверены date(dM)? Здесь возвращается «25 июня». (языковой стандарт установлен в en_US) Возможно, «j» и «n» будут лучше работать, так как «d» и «m» возвращают значения 0, дополненные шириной 2.
manatwork
@manatwork Вы правы. Это была моя ошибка. Это вы заметили это.
Исмаэль Мигель
1

Задача 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]
flawr
источник
1

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

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

pneumonoultramicroscopicsilicovolcanoconiosis

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

/an 01/.test(Date())&&alert("Happy New Year!")
user2428118
источник
1

Задача 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

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

Стьюи Гриффин
источник