Насколько хорошо вы знаете сайт? Давайте разберемся.

Это задача полицейских и грабителей . Нить грабителя.

Как полицейский, вам нужно:

1. Найдите не удаленный, не закрытый запрос на этом сайте, чтобы ответить. Задача не может иметь следующие теги: полицейские и грабители , конкурс популярности , кодовый троллинг , закулисный , занятой бобер , царь горы , подсказки , цепочка ответов . Задача должна иметь ограничения на допустимый вывод.
2. Написать действительное представление на вызов, в свободном языке найден на Википедии или esolangs.org или tryitonline . Представление не должно быть конкурсным, только действительным. РЕДАКТИРОВАТЬ: Хеширование в вашем представлении не допускается
3. Дать представление здесь, сохраняя вызов в секрете. Вы должны опубликовать всю заявку, а также язык (и версию, если применимо).

Через неделю, если никто не нашел ответ, на который вы отвечаете, вы можете опубликовать ответ, на который отвечает ваше сообщение, и в этот момент ваше сообщение безопасно . Это стоит N баллов, где N - количество голосов за вызов (по состоянию на 2016-11-17 ) (чем выше, тем лучше)

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

Примечания:

• Если для запроса требуется вывод X, а вы выводите XYили YXгде Yнаходится что-то, кроме пробелов, отправка не подходит для этого вызова.
• Вызов, более новый, чем 2016-11-17, не допускается.
• Разрешены языки, более новые, чем скрытый вызов.
• Я оставляю за собой право запретить определенные вызовы, если они широко применяются (могут применяться к большинству всех представлений).
• Спасибо Дэниелу за первоначальную идею!

Uncracked Материалы:

<script>site = 'meta.codegolf'; postID = 5686; isAnswer = false; QUESTION_ID = 100357;</script><script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>jQuery(function(){var u='https://api.stackexchange.com/2.2/';if(isAnswer)u+='answers/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJeRCD';else u+='questions/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJO6t)';jQuery.get(u,function(b){function d(s){return jQuery('<textarea>').html(s).text()};function r(l){return new RegExp('<pre class="snippet-code-'+l+'\\b[^>]*><code>([\\s\\S]*?)</code></pre>')};b=b.items[0].body;var j=r('js').exec(b),c=r('css').exec(b),h=r('html').exec(b);if(c!==null)jQuery('head').append(jQuery('<style>').text(d(c[1])));if (h!==null)jQuery('body').append(d(h[1]));if(j!==null)jQuery('body').append(jQuery('<script>').text(d(j[1])))})})</script>

Пип , 9 байт ( безопасно , 15 баллов)

(q`\w+`1)

Что это должно быть легко понять, но вопрос в том, почему ... ( TIO )

Задача была « Какой язык?» Цель: разобрать имя языка программирования из заголовка ответа PPCG. Например:

Input: <h1>JavaScript, 13 chars / 32 bytes</h1>
Desired Output: JavaScript

Я не уверен, что это не соответствует «У задачи должны быть ограничения на допустимый результат», поскольку это тест с тестовой батареей, оцениваемый как «процент тестов, которые вы получили правильно», и, следовательно, не требует, чтобы результат был правильным для всего ввода. Однако я скажу, что приведенный выше код дает примерно 60% правильной скорости, что неплохо для чего-то такого простого.

Perl - взломан DLosc

Давайте дадим легкий для людей не esolang

Бежать с -nl

say $_ ~~ reverse y-"({[]})"-")}][{("-r;;r-")}][{("-"({[]})"-y esrever ~~ _$ yas

Задача: удобная палиндромная проверка

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

Гексагония , 548 байт, трещины

69;{108;\_1$;;;/0;108\56;19|1^\6/15\;72_$23371<};;!;6;33|;;015><;;7;@3?;43+1586;2_3219><11;;'_8;;;2_|3;81|2<|8517;327}1_23;1;4$%;_4{5.1;1332_3;029&;'_};;1..527;2'..35;5212_>97;$;2/0;-;3_2;/233;08.._\901;0/13'}92...>/>/57\53;633;4'22;/|~>;441;45;;$161;371;3/;3.7026;`208;1<}>27;140;217;11.0;/2;692;<01/2;301;18;31/;10;/3;44<1914/111;{98;38;;;13/4;<;3;1;;/;112;<.$13032;..27;1;222/1;0<6..1;0;'..933721389/9<6;.;3;37..;;875;*;;0[1;287]59..902;;2;12;1;59;;3#..4;;1=249$345249;...;012}021#>/;44>114/4201;;;3>0;>;24;3/;;116._4>337;237/$5_>1{32;102;255;'_

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

Perl, сейф , 18 баллов

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

perl -n0E '/.*/;s/(^0|A)(.{@{+}})?0/A$2A/s||s/0(.{@{+}})?A/A$1A/s?redo:say/A$/+0'

Этот код не запутан (только в гольфе). (Это подразумевает, что -n0Eэто не обязательно).

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

Задача состояла в том, можно ли решить лабиринт? ,

Этот код найдет каждую достижимую ячейку лабиринта (и пометит их с помощью a A): если ячейка касается ячейки, помеченной символом a A, она достижима, и мы помечаем ее Aтоже; и мы делаем это снова ( redo). Это делается благодаря двум регулярным выражениям: s/(^0|A)(.{@{+}})?0/A$2A/sпроверяет, находится ли пробел справа или снизу A, а s/0(.{@{+}})?A/A$1A/sпроверяет, находится ли пробел слева или сверху а A. В конце, если в последней ячейке есть Aдостижимость, в противном случае это не так (это то, что say/A$/+0проверяет; +0здесь, чтобы убедиться, что результат будет 0или 1вместо пустой строки и 1).
Обратите внимание, что /.*/будет соответствовать всей строке, таким образом, настройка@+до индекса конца первой строки, который соответствует размеру строки, который позволяет использовать .{@{+}}для соответствия ровно столько символов, сколько имеется в строке. ( @{+}эквивалентно @+, но только первое может использоваться в регулярных выражениях)

Чтобы запустить это:

$ perl -n0E '/.*/;s/(^0|A)(.{@{+}})?0/A$2A/s||s/0(.{@{+}})?A/A$1A/s?redo:say 1-/0$/' <<< "0000001
0000010
1111011
0000000"
1

(и если вы замените 1111011строку на 1111111, она больше не будет решаться, и 0вместо нее будет вывод 1)

Perl, 56 байт, Safe (14 баллов)

undef$/;print+(<>^<>)=~y/\x81-\xff\x00-\x80/\x01-\xff/dr

Задача состояла в том, этот один , требуя , чтобы создать алгоритм сравнивает; Вы должны иметь возможность вводить два файла и выводить diff, или вводить файл и diff и выводить другой файл. Оценка этой задачи - это вызов кода , что делает наименьшее различие победителем; тем не менее, этот вызов не требует, чтобы ответ был конкурентным, просто соответствовал спецификации, поэтому я вместо этого написал отличную программу, которая просто использует XOR для объединения входных данных (это означает, что одна и та же программа работает для различий и ун-сравниваете).

Самое сложное - воспроизвести длину оригинальных файлов. Входные данные указываются как ASCII, который является семибитным набором символов, что позволяет мне использовать восьмой бит для отслеживания длины файла. При дифференцировании мы устанавливаем старший бит каждого байта, используя y///инструкцию (которая немного более запутана, чем была бы битовая арифметика). При недифференцировании (распознается, если заметить, что на входе уже установлен старший бит), мы удаляем NUL из вывода. (Я только что понял, что это не получится, если на входе содержатся байты NUL; однако, задача определяется с помощью тестовой батареи, и, к счастью, я не думаю, что в батарее есть байты NUL. Если они есть, то эта программа будет некорректной и должна быть дисквалифицирована, проблема с полицейскими и грабителями в том, что никто не имеет достаточно информации, чтобы указать на легко исправленные недостатки в вашем ответе!)

Октава, 15 баллов! БЕЗОПАСНЫЙ

@(x,y)find((v=((z=cumsum(x.^2))(y:end)-[0,z(1:end-y)]))==max(v),1)-1

Попробуйте это онлайн здесь .

Объяснение:

Код принимает входную строку, xсодержащую единицы и нули, 10010110110101и целое число y.

Чтобы найти скользящую среднюю последовательности в MATLAB / Octave, вы можете сделать:

z = cumsum(x);
movmean = z(y:end) - [0 z(1:end-y)];

Поскольку нас интересует только местоположение максимума, а не фактические значения, нам не нужно заботиться о преобразовании строки в числа. (x.^2)возводит в квадрат все ASCII-значения 48,49для 0,1. Это необходимо, поскольку Octave не может cumsumнапрямую использоваться персонажами. cumsum(+x)будет на два байта короче, но покажет, что xэто строка.

Это на самом деле довольно хорошо для гольфа (за исключением .^2вместо +). Конечно, свертка была бы проще.

MATL . Трещины

&:"@FYAYm7>vs

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

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

C #, 590 байт, треснувший

(I,N)=>{string R="",p="`1234567890-=",P="~!@#$%^&*()_+",q="qwertyuiop[]\\",Q="QWERTYUIOP{}|",a="asdfghjkl;\'",A="ASDFGHJKL:\"",z="zxcvbnm,./",Z="ZXCVBNM<>?";foreach(var c in I){var f=c+"";if(p.Contains(f))R+=p[(p.IndexOf(c)+N)%13];else if(P.Contains(f))R+=P[(P.IndexOf(c)+N)%13];else if(q.Contains(f))R+=q[(q.IndexOf(c)+N)%13];else if(Q.Contains(f))R+=Q[(Q.IndexOf(c)+N)%13];else if(a.Contains(f))R+=a[(a.IndexOf(c)+N)%11];else if(A.Contains(f))R+=A[(A.IndexOf(c)+N)%11];else if(z.Contains(f))R+=z[(z.IndexOf(c)+N)%10];else if(Z.Contains(f))R+=Z[(Z.IndexOf(c)+N)%10];else R+=c;}return R;};

Вероятно, довольно легко, также довольно длинная программа, _,

05AB1E , 27 байт, трещины!

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

ávyl•B;£¡´•54B•2ît•‡y.li(}O

Объяснение (для вызова):

á                             # Keep all the letters of the input string
 vy                           # For each letter...
   l                          #   Convert to lowercase
    •B;£¡´•54B                #   String that turns into 'pnbrqk'
              •2ît•           #   Compressed int: 133591
                   ‡          #   Transliterates the following:
                                    p -> 1
                                    n -> 3
                                    b -> 3
                                    r -> 5
                                    q -> 9
                                    k -> 1
                    y.li }    #   If the current letter is lowercase...
                        (     #     Negate that number
                          O   # Sum up the result

Использует кодировку CP-1252 . Попробуйте онлайн!

아희 (Aheui) , 0 байт, трещины

Попробуй это здесь! (Программа уже набрана для вас: p)

Питон, 935 байт

def oo000 ( num ) :
 return - ~ num
def ii ( num ) :
 return - ( oo000 ( oo000 ( ~ num ) ) )
def oOOo ( num1 , num2 ) :
 while num2 > 0 :
  num1 = oo000 ( num1 )
  num2 = ii ( num2 )
 return num1
 if 59 - 59: Oo0Ooo . OO0OO0O0O0 * iiiIIii1IIi . iII111iiiii11 % I1IiiI
def IIi1IiiiI1Ii ( num1 , num2 ) :
 I11i11Ii = num2
 oO00oOo = 0
 while I11i11Ii > 0 :
  oO00oOo = oOOo ( oO00oOo , num1 )
  I11i11Ii = ii ( I11i11Ii )
  if 92 - 92: O0O / oo000i1iIi11iIIi1 % Iii1IIIiiI + iI - Oo / o0O
 return oO00oOo
def hgj ( num1 , num2 ) :
 I11i11Ii = num2
 oO00oOo = 1
 while I11i11Ii > 0 :
  oO00oOo = IIi1IiiiI1Ii ( oO00oOo , num1 )
  I11i11Ii = ii ( I11i11Ii )
  if 48 - 48: iII111i % IiII + I1Ii111 / ooOoO0o * o00O0oo
 return oO00oOo
def O0oOO0o0 ( num1 , num2 ) :
 return oOOo ( num1 , - num2 )
 if 9 - 9: o0o - OOO0o0o
 if 40 - 40: II / oo00 * Iii1IIIiiI * o0o . ooOoO0o
print(hgj ( 9 , 9999 ))
# dd678faae9ac167bc83abf78e5cb2f3f0688d3a3

Извините, я использовал обфускатор, но это не запрещено и намного проще. (И у меня не было всего этого времени, чтобы сделать это самостоятельно ...)

Рубин ( взломан DLosc )

p n = gets.to_i
p n = n*(3*n-1)/2 until n % 7 == 0

MATL . Сейф , 93 балла

dP7EGn:q^1J2/h)ts_hX=Gs[BE]Wd=~>~GBz*

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

объяснение

Проблема заключалась в экологическом следе исходного кода .

Код вычисляет вес Хэмминга (количество единиц) в двоичном представлении кодов ASCII входной строки; за исключением того, что строка testвыводит 0(вместо ее веса Хэмминга, который есть 17).

Специальный корпус этой нити немного запутан. Программа сначала вычисляет массив последовательных различий ASCII-кодов ввода и инвертирует его. За testэто дает [1 14 -15].

Затем вычисляется массив, образованный первыми nстепенями 14( [1 14 196 ...]), где nдлина ввода; и первые floor(n/2)значения сохраняются. Так что для ввода testэто дает [1 14]. Отрицательная сумма добавляется к этому массиву, который дает [1 14 -15]для ввода test. Это проверяется на равенство с обратным массивом последовательных различий, который был ранее получен.

С другой стороны, сумма кодов ASCII входных символов вычисляется и сравнивается с 448генерируемой (последовательной) разностью элементов в массиве [2^6 2^9](где ^обозначает мощность).

Ввод test- единственная строка с обратными последовательными различиями формы [1 14 -15]и суммы 448. Различия []или [1](для более коротких строк inoyt) не совместимы с общей суммой 448. Различия [1 14 196]или больше не могут быть достигнуты с помощью символов ASCII.

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

CJam ( безопасно , 21 балл)

{W+W%~1{1$)}{)a1${\(+W%{1$1$-2=>}{+}w}{\;}?)_@*\+~}w+}

Это анонимный блок (функция).

Python 3, ~ 2000 байт, (безопасно: 23 балла)

Оригинальная программа

exec("\n))o0000o000o<)]))]00000o000o[0o0o0o0o0o0o0o0o0o(00000000000000o0o(000000000000000o0o ni oooo0oooo rof)))0o0o0o0o0o0o0o0o0o(00000000000000o0o(000000000000000o0o ni 00oo00oo00oo00oo00oo rof]oooo0oooo[]00oo00oo00oo00oo00oo[0o0o0o0o0o0o0o0o0o(000ooo000ooo000o[ +]0o0o0o0o0o0o0o0o0o ni 00oo00oo00oo00oo00oo rof)00oo00oo00oo00oo00oo(000ooo000ooo000o[ni ooo000ooo000o rof)ooo000ooo000o(o0o0o0o0o-o0000o000o(000ooo000ooo000o(00o00o00o(tnirp\n)00000o000o,00000o000o(tresni.o0o0o0o0o0o0o0o0o0o:))00000000000000o0o=yek,0o0o0o0o0o0o0o0o0o(xam(00000000000000o0o<)o0o0o0o0o0o0o0o0o0o(00000000000000o0o elihw \n:)]00000o000o[]o0oooo,0o0o0o0o0o0o0o0o0o[( ni o0o0o0o0o0o0o0o0o0o rof\n;'=01NgwiNgwSNbBibpBybw8GMwAzbw8GM'b,]0o0o0o0o00oo ni ooooo0o00oo rof]]::0oooooo0oooo[))ooooo0o00oo(0oooooo(o0oooo ni ooo000ooo000o rof)ooo000ooo000o(00o00o00o[[=ooooo00oo,0o0o0o0o0o0o0o0o0o\n)'=kSZsBXd0BCLn5WayR3cgwCdulGK'b(0o0o.)(0o0ooo0o00ooo.o000oo esle o0000o000o fi o0000o000o+o0000o000o=0oooooo0oooo;)000000000000000o0o(o00oo00o=000000000000000o0o;)))(edoced.)o0o(0oo000o(000000o(o000oo,))(]o0000o000o[]edoced.)'==QbhRHa'b(0oo000o,'oo0o0o00o'[(oo0o0oo=o0o0o0o0o,oo0o0o0oo\n;)00000000000000o0o(o00oo00o,))(edoced.)'vJHZ'b(0oo000o(o00oo00o,)'bin'(o00oo00o=00000000000000o0o,0oooooo,o0oooo;))0000o0o0o(000000o(o000oo:0000o0o0o adbmal = o00oo00o ;)))(0o0oo00o(0oooooo(0o0oo0oo=0o0o0o0o00oo\n00000000000001**o0000o000o=o0000o000o;))(edoced.)'=cSbhRHanwCd1BnbpxyXfRncvBXbp91Xs4WavpmLnAyJ'b(0oo000o(o000oo=o0oo0oo00o,0o0oo00o,o0oo0oo,0o0oo0oo;edoced46b.)000oo0o(oo0o0oo=0oo000o\n;'==QYsxGKb92bwADMvVCN8EDIm9mcg8GMvBSauBybw82bwADMvBzbdliKq4SN'b ,))0o0oo00oo(000000o(__tropmi__ :0o0oo00oo adbmal,'base64',]0o0oo00oo[:0o0oo00oo adbmal = oo00oo00oo00oo00oo00oo,oo0o0oo,000oo0o,0oooooo\n;tni,'range','len','==Abh1mYkFGIv9GMwAzb682bwADMvBSYuRGIv9GMvBzbw82buYWYjR3bylWYshybvBDMw8WLxkiKqITJv9GMwAzb'b,lave,0**0000000000000009,0 ,]1-::[0o0ooo0o00o0oo:0o0ooo0o00o0oo adbmal,mus = 00o00o00o,000000000000000o0o,00000000000000o0o,o0o,o000oo,o0000o000o,00000o000o,000000o,000ooo000ooo000o\n"[::-1])

Вызов

На самом деле это ответ на мой собственный вызов, Primenary Strings . Я выбрал это, поскольку почти все будет выводить 0, кроме нескольких входных данных, которые грабитель вряд ли будет вводить. Код представляет собой простой алгоритм, но сильно запутанный (вручную).

Пип , 13 байт

V$.C(A*a-A9)a

Попробуйте онлайн (введите аргументы, а не входные данные).

JavaScript, 533 байта, взломан! Дэйв

_=this;[490837,358155,390922].map(y=function(M,i){return _[[
U=[y+[]][+[]]][+[]][i]]=_[M.toString(2<<2<<2)]});function g(
s){return Function("a","b","c","return "+s)};e=g(u(["","GQ9\
ZygiYTwyPzE6YSpk","C0tYSki","SkoYSkvZChhLWIpL2QoYikg"].join(
"K")));h=g("A=a,B=b,g('A(a,B(a))')");j=g("a/b");L=g("Z=a,Y=\
b,g('Z(a,Y)')");k=L(j,T=2);F=g(u("KScpKWIsYShFLCliLGEoQyhEJ\
yhnLGM9RSxiPUQsYT1D").split("").reverse().join(""));RESULT=F
(h(e,k),j,g("_[U[10]+[![]+[]][+[]][++[+[]][+[]]]+[!+[]+[]][\
+[]][+[]]+17..toString(2<<2<<2)].pow(T,a)"));

Не мое любимое запутывание моё, но вроде как аккуратно. Звоните как RESULT(inputs).

Я мог бы присудить +50 баллов за вознаграждение, если вы подробно объясните, что мой код делает вместе с вашим крэком. (Они не должны быть вместе, поэтому не стесняйтесь FGITW, если это соответствует вашим прихотям.)

Pyke, 3458 байт, SAFE , оценка 99

wB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddsQI30>Q%)

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

Есть несколько (30) 0x1bбайтов, которые, похоже, были съедены SE.

Октава, 40 баллов. БЕЗОПАСНЫЙ

Слегка запутанный ответ на довольно популярный вызов.

y=find((x=mod(input('')*2,32))>12);sign(sum(x.*[1-y:nnz(x+8)-y]))

Я рекомендую проверить это на октаву-онлайн . Ideone не так хорош, когда дело доходит до STDIN.

Это был симулятор рычага 2015 года. Ввод в форму '123^32. Вывод будет -1 0 1для левого тяжелого, сбалансированного и правого тяжелого в этом порядке.

Это выглядит так, когда игра полностью в гольф :

s=mod(input(''),16);i=find(s>9);s*[1-i:numel(s)-i]'*inf

Это выводит -Inf, NaN, Infдля L, B, R соответственно.

Haskell, БЕЗОПАСНЫЙ

m f=map(f<$>)
g=reverse.("":)
f s|(f:c:s)<-m fromEnum.g.words$s,
    (f:c:s)<-init.unwords.g.m(\s->toEnum$if c!!0==s||s==sum(-32:c)then(last$f)else s)$s=init$s

Попробуйте это на Ideone . "Использование":

Prelude> f "Programming Puzzles & Code Golf"
"rogramming Puzzles "

В задании «Строка Шенанигана» каждому дается строка и два символа, а затем следует заменить каждое вхождение первого символа вторым. Однако входные данные представляют собой одну строку, содержащую только фактическую строку в кавычках и разделенные пробелами из двух символов:

Prelude> f "\"Hello, World!\" l r"
"Herro, Worrd!"

TeX, 240 байт, SAFE , оценка 129

\let\N\newcount\let\I\ifnum\let\A\advance\let\E\else\N\a\N\b\N\c\def\D#1:#2:#3:{\I#1>#2\A#1by-#2\D#1:#2:#3:\E\I#1=#2 #3=1\E#3=0\fi\fi}\def\P#1:#2:{\I#1>#2\a=#1\D\a:#2:\c:\I\c=0\b=#2\A\b by1\P#1:\the\b:\E N\fi\E\I#1=1 N\E Y\fi\fi}\P1:2:\end

Сохранить как jeopardy.tex, затем запустить pdftex jeopardy.texи открыть jeopardy.pdf.

Итог: PDF с текстом N(и страница № 1).

Python 3, треснул!

Писать это было весело, хотя в конце концов это было легко взломать :)

Z,O=__import__('time').strftime,401*5;from base64 import*;Q,I=(Z('%Y')),(O/401)*2;_=int(Q);D,P=(O,-~_),int(Q[~1:]);Q,I=(6+(P-eval(b64decode(b'KHN1bShbeCU0PDEgZm9yIHggaW4gcmFuZ2UobWluKEQpLG1heChEKSldKSk=').decode()+'*-1'*(O>_)))/10,'3'+repr(((P-10)*3)+10));print(Q,I)

Pyth - взломанный Maltysen

Если это поможет, Пиф не был ни одним из ответов на скрытый вызов.

u=.+G.*A

Попробуйте!

C #, 91 байт

_=>{int b=0,w=0;for(;1>w||0<*(_-1);b+=++w**_++<<(9*w));return b%(3<w?903302656:41458688);};

Mathematica, 161 байт

Which[LetterQ@#,If[UpperCaseQ@#,ToUpperCase,#&][FromLetterNumber~Array~LetterNumber@#],DigitQ@#,Array[IntegerString,FromDigits@#+1,0],True,#]&/@Characters@#<>""&

BrainFuck - 140 байт, взломанный daHugLenny

,>,>,>-[>+<-----]>---[<+>-]<[<<<->>>->+<]>[<<<->>>->+<]>[<<<->>>-]<<<[>+<-]<[>>++++++++++<<-]<[>>>>++++++++++[<++++++++++>-]<<<<-]>>>[>.+<-]

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

C ++ 14, Cracked

#include<vector>

auto h(auto i){return 0;}
auto h(auto i, auto x, auto...p){
 return x+(i-1?h(i-1,p...):0);
}

auto g(auto v){return v;}
auto g(auto v,auto x, auto...p){
 v.push_back(h(x,x,p...));
 return g(v,p...);
}

auto f(auto...p){
 return g(std::vector<int>{},p...);
}

Принимает переменное число параметров и возвращает vector<int> .

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

int main() {
 auto v = f(4,7,3,4,5);
 for (auto i:v) std::cout << i << ", ";
 std::cout << std::endl;
}

Mathematica, 34 байта, трещины

±1={±0={}};±n_:=Array[±#&,n,0]

Именованная функция ( ±).

Рубин, 50 байтов

count = 0; 400.times do count +=1; end; puts count

выход: 400

Python 2.7, 45 байт

import numpy;lambda a,n,t:numpy.arange(a,t,n)

Подсказка (или, может быть, нет): "рыба использует numpy".

2016.11.23 - второй намек: «Не оставляйте ничего плавающего!»