Você conhece bem o site? Vamos descobrir.

Este é um desafio de policiais e ladrões . Fio do ladrão.

Como policial, você precisa:

1. Encontre um desafio não excluído e não fechado neste site para responder. O desafio não pode ter as seguintes marcas: COPS-e-ladrões , popularity-contest , code-corrico , dissimulados , ocupado-castor , king-of-the-hill , dicas , resposta-encadeamento . O desafio deve ter restrições na saída válida.
2. Escreva um envio válido para o desafio, em um idioma gratuito encontrado na Wikipedia ou esolangs.org ou tryitonline . O envio não precisa ser competitivo, apenas válido. EDIT: Hashing no seu envio não é permitido
3. Poste a submissão aqui, mantendo o desafio em segredo. Você deve postar todo o envio, bem como o idioma (e versão, se aplicável).

Depois de uma semana, se ninguém encontrou o desafio que você está respondendo, você pode postar o desafio que seu envio está respondendo; nesse ponto, seu envio está seguro . Vale N pontos, onde N é o número de votos positivos no desafio (a partir de 17/11/2016 ) (Maior é melhor)

Para resolver seu desafio, os ladrões precisam encontrar qualquer desafio para o qual o envio seja válido.

Notas:

• Se um desafio exigir uma saída de Xe você produzir XYou YXonde Yhouver algo além de espaço em branco, o envio não será válido para esse desafio.
• Não é permitido um desafio mais recente que 17/11/2016.
• Idiomas mais recentes que o desafio oculto são permitidos.
• Reservo-me o direito de proibir certos desafios se eles forem amplamente aplicáveis ​​(podem ser aplicados à maioria de todos os envios).
• Agradeço a Daniel pela ideia inicial!

Envios sem rachaduras:

<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>

Pip , 9 bytes ( seguro , 15 pontos)

(q`\w+`1)

O que faz deve ser fácil descobrir, mas a questão é por que ... ( TIO )

O desafio foi o que é o idioma? O objetivo: analisar o nome da linguagem de programação a partir de um cabeçalho de resposta PPCG. Por exemplo:

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

Não tenho certeza se isso está em conflito com "O desafio deve ter restrições à saída válida", já que é um desafio de bateria de teste marcado por "porcentagem de testes que você acertou" e, portanto, não exige que a saída esteja correta para todas as entradas. No entanto, direi que o código acima obtém uma taxa correta de 60%, o que não é ruim para algo tão simples.

Perl - Rachado por DLosc

Vamos dar um fácil para as pessoas que não são esolang

Correr com -nl

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

Desafio: Verificador conveniente de palíndromo

O código falha após a impressão da veracidade, mas, de acordo com esta meta postagem, desde que produza a saída correta antes de travar e qualquer erro seja enviado para o STDERR, é uma solução válida.

Hexagonia , 548 bytes, Rachado

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;'_

Experimente online!

Perl, seguro , 18 pontos

Editar : modifiquei o final do código (consulte o histórico de edições) para lidar com um caso de ponta (o desafio não diz nada sobre isso, e o autor não respondeu quando perguntado sobre isso, mas pelo menos esse código lida com isso) . Mas o algoritmo e a lógica do código permanecem os mesmos.

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

Este código não é ofuscado (apenas golfe). (Isso implica que -n0Enão são opcionais).

Não sei se isso é difícil ou não, mas acho que serei consertado quando alguém o quebrar.

O desafio foi o labirinto pode ser resolvido? .

Este código encontrará todas as células acessíveis do labirinto (e marque-as com a A): se uma célula toca uma célula marcada com a A, é alcançável e também a marcamos A; e fazemos isso de novo ( redo). Isso é feito graças a duas expressões regulares: s/(^0|A)(.{@{+}})?0/A$2A/sverifica se um espaço está à direita ou na parte inferior de a A, enquanto s/0(.{@{+}})?A/A$1A/sverifica se há um espaço à esquerda ou em cima de a A. No final, se a última célula contém um A, é alcançável, caso contrário, não é (é isso que say/A$/+0verifica; o +0está aqui para garantir que o resultado será 0ou em 1vez de uma string vazia e 1).
Observe que /.*/corresponderá a uma linha inteira, configurando assim@+ao índice do final da primeira linha, que passa a ser o tamanho de uma linha, que permite usar .{@{+}}para combinar exatamente o número de caracteres que há em uma linha. ( @{+}é equivalente a @+, mas apenas o primeiro pode ser usado em regex)

Para executá-lo:

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

(e se você substituir a 1111011linha por 1111111, ela não será mais solucionável e a saída será em 0vez de 1)

Perl, 56 bytes, Seguro (14 pontos)

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

O desafio foi esse , exigindo a criação de um algoritmo diferente; você precisa poder inserir dois arquivos e gerar um diff, ou inserir um arquivo e um diff e gerar o outro arquivo. A pontuação desse desafio é um desafio de código , tornando o menor diferencial o vencedor; no entanto, esse desafio não exige que a resposta seja competitiva, simplesmente compatível com as especificações, por isso escrevi um programa diferente de maneira golfista, que simplesmente usa o XOR para combinar as entradas (o que significa que o mesmo programa funciona para diferenciar e não diferindo).

A parte mais difícil é reproduzir o tamanho dos arquivos originais. A entrada é especificada como ASCII, que é um conjunto de caracteres de sete bits, permitindo assim que eu use o oitavo bit para rastrear o comprimento do arquivo. Ao diferir, definimos o bit alto de cada byte usando uma y///instrução (que é um pouco mais ofuscada do que a aritmética bit a bit seria). Ao cancelar a diferenciação (reconhecida através da observação de que a entrada já possui o bit alto definido), removemos as NULs da saída. ( Acabei de perceber que isso falharia se a entrada contivesse NUL bytes; no entanto, o desafio é definido em termos de uma bateria de teste e, felizmente, acho que não há NUL bytes na bateria. Se houver, esse programa estaria incorreto e precisaria ser desqualificado; um problema com policiais e ladrões é que ninguém mais tem informações suficientes para apontar falhas facilmente corrigidas na sua resposta!)

Oitava, 15 pontos! SEGURO

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

Experimente online aqui .

Explicação:

O código usa uma sequência de entrada xcontendo uns e zeros 10010110110101e um número inteiro y.

Para encontrar a média móvel de uma sequência no MATLAB / Octave, você pode:

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

Como estamos interessados ​​apenas na localização do valor máximo, não nos valores reais, não precisamos nos preocupar em converter a sequência em números. (x.^2)esquadra todos os valores ASCII 48,49para 0,1. Isso é necessário, pois o Octave não pode ser usado cumsumdiretamente nos caracteres. cumsum(+x)seria dois bytes mais curto, mas revelaria que xé uma string.

Isso é realmente muito bem jogado (exceto no .^2lugar de +). Obviamente, a convolução seria mais simples.

MATL . Rachado

&:"@FYAYm7>vs

Experimente online!

Eu indiquei entrada e saída, mesmo que não seja necessário. Como está no histórico de edição de qualquer maneira: o programa insere dois números e gera um número.

C #, 590 bytes, Rachado

(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;};

Provavelmente muito fácil, também um programa bastante longo, _,

05AB1E , 27 bytes, com defeito !

Para esse envio, também é necessária uma entrada para que ele funcione. Não deve ser muito difícil de quebrar.

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

Explicação (para o desafio):

á                             # 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

Usa a codificação CP-1252 . Experimente online!

A (Aheui) , 0 bytes, Rachado

Experimente aqui! (O programa já está digitado para você: p)

Python, 935 bytes

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

Desculpe, usei um ofuscador, mas não é proibido e muito mais fácil. (E eu não tive todo esse tempo para fazer isso sozinho ...)

Ruby ( quebrado pelo DLosc )

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

MATL . Cofre , 93 pontos

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

Experimente online!

Explicação

O desafio foi a pegada ecológica do código fonte .

O código calcula o peso de Hamming (número de unidades) na representação binária dos códigos ASCII da sequência de entrada; exceto que a string é testgerada 0(em vez do peso de Hamming, que é 17).

O invólucro especial dessa corda é um pouco ofuscado. O programa primeiro calcula a matriz de diferenças consecutivas dos códigos ASCII da entrada e a reverte. Para testisso dá [1 14 -15].

Então, a matriz formada pelas primeiras npotências de 14é calculada ( [1 14 196 ...]), onde nestá o comprimento da entrada; e os primeiros floor(n/2)valores são mantidos. Então, para entrada testisso dá [1 14]. A soma negada é anexada a essa matriz, que fornece [1 14 -15]entrada test. Isso é testado quanto à igualdade com a matriz reversa de diferenças consecutivas que foram obtidas anteriormente.

Por outro lado, a soma dos códigos ASCII dos caracteres de entrada é calculada e comparada com 448, gerada como a diferença (consecutiva) dos elementos na matriz [2^6 2^9](onde ^denota energia).

A entrada testé a única sequência com diferenças consecutivas invertidas da forma [1 14 -15]e da soma 448. Diferenças []ou [1](para seqüências de caracteres inoyt mais curtas) não são compatíveis com uma soma total de 448. [1 14 196]Não é possível obter diferenças ou maiores com caracteres ASCII.

O código verifica se o resultado do teste para a primeira condição (diferenças consecutivas) não é menor que o resultado negado da segunda condição (soma total). Isso fornece 0se e somente se ambas as condições foram satisfeitas. Finalmente, isso é multiplicado pelo número de unidades na representação binária dos códigos ASCII da entrada.

CJam ( seguro , 21 pontos)

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

Este é um bloco anônimo (função).

Python 3, ~ 2000 bytes, (seguro: 23 pontos)

Programa Original

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])

Desafio

Esta é de fato uma resposta para o meu próprio desafio, Primenary Strings . Eu escolhi isso, pois quase tudo sairá 0, exceto algumas entradas nas quais um ladrão provavelmente não entrará. O código é um algoritmo simples, mas muito ofuscado (à mão).

Pip , 13 bytes

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

Experimente online (dê entrada como Argumentos, não Entrada).

JavaScript, 533 bytes, Rachado! por Dave

_=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)"));

Não é minha ofuscação favorita, mas é bem legal. Ligar como RESULT(inputs).

Eu poderia conceder uma recompensa de +50 pontos se você explicar em detalhes o que meu código está fazendo junto com o seu crack. (Eles não precisam ficar juntos, sinta-se à vontade para o FGITW, se isso for adequado aos seus caprichos.)

Pyke, 3458 bytes, SAFE , pontuação 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%)

Experimente aqui!

Existem alguns (30) 0x1bbytes que parecem ter sido comidos pelo SE.

Oitava, 40 pontos. SEGURO

Resposta ligeiramente ofuscada para um desafio bastante popular.

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

Eu recomendo testar isso em oitava-online . Ideone não é tão bom quando se trata de STDIN.

Este foi o desafio do simulador de alavanca de 2015. Entrada no formulário '123^32. A saída será -1 0 1para Pesado para a esquerda, Equilibrado e Pesado para a direita nessa ordem.

É assim quando está totalmente jogado :

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

Isso gera -Inf, NaN, Infpara L, B, R, respectivamente.

Haskell, SAFE

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

Experimente em Ideone . "Uso":

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

No desafio das travessuras das cordas, é dada uma sequência e dois caracteres e deve substituir todas as ocorrências do primeiro caracter pelo segundo. No entanto, a entrada é uma sequência que contém apenas a sequência real entre aspas e os dois caracteres em branco com espaço em branco:

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

TeX, 240 bytes, SAFE , pontuação 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

Salve como jeopardy.texe execute pdftex jeopardy.texe abra jeopardy.pdf.

Resultado: um PDF com o texto N(e o número da página 1).

Python 3, Rachado!

Escrever isso foi hilário, apesar de ser facilmente decifrado no final :)

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 - Rachado por Maltysen

Se ajudar, Pyth não foi uma das respostas para o desafio oculto.

u=.+G.*A

Experimente!

C #, 91 bytes

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

Mathematica, 161 bytes

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

BrainFuck - 140 bytes, rachado por daHugLenny

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

Experimente aqui!

C ++ 14, rachado

#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...);
}

Pega um número variável de parâmetros e retorna a vector<int>.

Uso:

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

Mathematica, 34 bytes, Rachado

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

Função nomeada ( ±).

Ruby, 50 bytes

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

resultado: 400

Python 2.7, 45 bytes

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

Dica (ou talvez não): "o peixe está usando numpy".

23/11/2016 - segunda dica: "Não deixe nada flutuando por aí!"