¿Qué tan bien conoces el sitio? Vamos a averiguar.

Este es un desafío de policías y ladrones . El hilo del ladrón.

Como policía, necesitas:

1. Encuentre un desafío no eliminado y no cerrado en este sitio para responder. El desafío no puede tener las siguientes etiquetas: policías y ladrones , concurso de popularidad , trolling de código , descuidado , castor ocupado , rey de la colina , consejos , encadenamiento de respuestas . El desafío debe tener restricciones en la salida válida.
2. Escriba una presentación válida para el desafío, en un idioma gratuito que se encuentre en Wikipedia o esolangs.org o tryitonline . La presentación no tiene que ser competitiva, solo válida. EDITAR: Hashing en su envío no está permitido
3. Publique la presentación aquí, manteniendo el desafío en secreto. Debe publicar el envío completo, así como el idioma (y la versión, si corresponde).

Después de una semana, si nadie ha encontrado el desafío que está respondiendo, puede publicar el desafío que su envío está respondiendo, en ese momento, su envío está seguro . Vale la pena N puntos, donde N es el número de votos a favor en el desafío (a partir de 2016-11-17 ) (Mayor es mejor)

Para descifrar su desafío, los ladrones deben encontrar cualquier desafío para el que el envío sea válido.

Notas:

• Si un desafío requiere un resultado de X, y usted genera un resultado XYo YXdónde Yhay algo más que un espacio en blanco, el envío no es válido para ese desafío.
• Un desafío más nuevo que el 2016-11-17 no está permitido.
• Se permiten idiomas más nuevos que el desafío oculto.
• Me reservo el derecho de prohibir ciertos desafíos si son ampliamente aplicables (podrían aplicarse a la mayoría de todas las presentaciones).
• ¡Gracias a Daniel por la idea inicial!

Envíos sin descifrar:

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

(q`\w+`1)

Lo que hace debería ser fácil de entender, pero la pregunta es por qué ... ( TIO )

El desafío era ¿Cuál es el idioma? El objetivo: analizar el nombre del lenguaje de programación de un encabezado de respuesta PPCG. Por ejemplo:

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

No estoy seguro de si esto entra en conflicto con "El desafío debe tener restricciones en la salida válida", ya que es un desafío de batería de prueba calificado por "porcentaje de pruebas que obtiene correcto", y por lo tanto no requiere que la salida sea correcta para todas las entradas Sin embargo, diré que el código anterior obtiene una tasa correcta del 60%, lo que no es malo para algo tan simple.

Perl - Agrietado por DLosc

Vamos a dar una fácil para las personas que no son esolang

Corre con -nl

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

Desafío: conveniente verificador de palíndromo

El código se bloquea después de imprimir la veracidad, pero de acuerdo con esta meta publicación, siempre que produzca la salida correcta antes de que se bloquee, y cualquier error se envíe a STDERR, es una solución válida.

Hexagonía , 548 bytes, agrietada

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

Pruébalo en línea!

Perl, seguro , 18 puntos

Editar : modifiqué el final del código (ver el historial de edición) para manejar un caso límite (el desafío no dice nada al respecto, y el autor no respondió cuando se le preguntó al respecto, pero al menos este código lo maneja) . Pero el algoritmo y la lógica del código siguen siendo los mismos.

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

Este código no está ofuscado (solo golfizado). (Esto implica que -n0Eno son opcionales).

No me doy cuenta de si esto es difícil o no, pero supongo que me solucionarán cuando alguien lo resuelva.

El desafío era ¿Se puede resolver el laberinto? .

Este código encontrará todas las celdas accesibles del laberinto (y las marcará con un A): si una celda toca una celda marcada con un A, es accesible y la marcamos con un Atambién; y lo hacemos de nuevo ( redo). Eso se hace gracias a dos expresiones regulares: s/(^0|A)(.{@{+}})?0/A$2A/scomprueba si hay un espacio a la derecha o en la parte inferior de a A, mientras que s/0(.{@{+}})?A/A$1A/scomprueba si hay un espacio a la izquierda o en la parte superior de a A. Al final, si la última celda contiene un Aes accesible, de lo contrario no lo es (eso es lo que say/A$/+0verifica; +0está aquí para asegurarse de que el resultado sea 0o en 1lugar de una cadena vacía y 1).
Tenga en cuenta que /.*/coincidirá con una línea completa, configurando así@+al índice del final de la primera línea, que resulta ser el tamaño de una línea, lo que permite usar para .{@{+}}que coincidan exactamente tantos caracteres como haya en una línea. ( @{+}es equivalente a @+, pero solo el primero se puede usar en expresiones regulares)

Para ejecutarlo:

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

(y si reemplaza la 1111011línea con 1111111, ya no se puede resolver, y la salida será en 0lugar de 1)

Perl, 56 bytes, seguro (14 puntos)

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

El desafío era este , que requería que crearas un algoritmo diferente; debe poder ingresar dos archivos y generar un diff, o ingresar un archivo y un diff y generar el otro archivo. La puntuación de ese desafío es el desafío de código , lo que hace que el más pequeño sea el ganador; sin embargo, este desafío no requiere que la respuesta sea competitiva, simplemente cumple con la especificación, por lo que escribí un programa diferente en forma de golf, que simplemente usa XOR para combinar las entradas (lo que significa que el mismo programa funciona para diferenciar y sin diferencias).

La parte más difícil es reproducir la longitud de los archivos originales. La entrada se especifica como ASCII, que es un conjunto de caracteres de siete bits, lo que me permite usar el octavo bit para rastrear la longitud del archivo. Al diferenciar, establecemos el bit alto de cada byte usando una y///instrucción (que está un poco más ofuscada que la aritmética bit a bit). Cuando no diferencie (se reconoce notando que la entrada ya tiene el bit alto establecido), eliminamos NUL de la salida. (Me acabo de dar cuenta de que esto fallaría si la entrada contuviera bytes NUL; sin embargo, el desafío se define en términos de una batería de prueba, y por suerte no creo que haya bytes NUL en la batería. Si los hay, entonces este programa sería incorrecto y necesitaría ser descalificado; un problema con policías y ladrones ¡Es que nadie más tiene suficiente información para señalar fallas fáciles de solucionar en su respuesta!)

Octava, 15 puntos! SEGURO

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

Pruébelo en línea aquí .

Explicación:

El código toma una cadena de entrada que xcontiene unos y ceros, 10010110110101y un número entero y.

Para encontrar el promedio móvil de una secuencia en MATLAB / Octave puedes hacer:

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

Como solo estamos interesados ​​en la ubicación del máximo, no en los valores reales, no necesitamos preocuparnos por convertir la cadena a números. (x.^2)ajusta todos los valores ASCII 48,49para 0,1. Esto es necesario ya que Octave no puede usar cumsumdirectamente en los personajes. cumsum(+x)sería dos bytes más corto pero revelaría que xes una cadena.

En realidad, esto está bastante bien golfizado (excepto en .^2lugar de +). Por supuesto, la convolución sería más simple.

MATL . Agrietado

&:"@FYAYm7>vs

Pruébalo en línea!

Indiqué entrada y salida incluso si no es necesario. Como de todos modos está en el historial de edición: el programa ingresa dos números y genera un número.

C #, 590 bytes, agrietado

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

Probablemente bastante fácil, también un programa bastante largo, _,

05AB1E , 27 bytes, ¡agrietado!

Para esta presentación, también se requiere información para que funcione. No debería ser demasiado difícil de descifrar.

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

Explicación (para el desafí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

Utiliza la codificación CP-1252 . Pruébalo en línea!

아희 (Aheui) , 0 bytes, Agrietado

Pruébalo aquí! (El programa ya está escrito para usted: 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

Lo siento, usé un ofuscador, pero no está prohibido y es mucho más fácil. (Y no tuve todo ese tiempo para hacerlo yo mismo ...)

Rubí ( agrietado por DLosc )

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

MATL . Seguro , 93 puntos

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

Pruébalo en línea!

Explicación

El desafío fue la huella ecológica del código fuente .

El código calcula el peso de Hamming (número de unidades) en la representación binaria de los códigos ASCII de la cadena de entrada; excepto que la cadena testsale 0(en lugar de su peso de Hamming, que es 17).

La carcasa especial de esa cadena está un poco ofuscada. El programa primero calcula la matriz de diferencias consecutivas de los códigos ASCII de la entrada y la invierte. Por testesto da [1 14 -15].

Luego, se calcula la matriz formada por las primeras npotencias de 14( [1 14 196 ...]), donde nestá la longitud de entrada; y floor(n/2)se guardan los primeros valores. Entonces, para la entrada testesto da [1 14]. La suma negada se agrega a esta matriz, que da [1 14 -15]como entrada test. Esto se prueba para la igualdad con el conjunto invertido de diferencias consecutivas que se obtuvo previamente.

Por otro lado, la suma de los códigos ASCII de caracteres de entrada se calcula y se compara con 448, generada como la diferencia (consecutiva) de los elementos en la matriz [2^6 2^9](donde ^denota potencia).

La entrada testes la única cadena con diferencias consecutivas invertidas de la forma [1 14 -15]y la suma 448. Las diferencias []o [1](para cadenas inoyt más cortas) no son compatibles con una suma total de 448. [1 14 196]No se pueden lograr diferencias o mayores con los caracteres ASCII.

El código verifica si el resultado de la prueba para la primera condición (diferencias consecutivas) no es menor que el resultado negado de la segunda condición (suma total). Esto da 0si y solo si ambas condiciones se cumplieron. Finalmente, esto se multiplica por el número de unos en la representación binaria de los códigos ASCII de la entrada.

CJam ( seguro , 21 puntos)

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

Este es un bloque anónimo (función).

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

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

Desafío

De hecho, esta es una respuesta para mi propio desafío, Primenary Strings . Elegí esto, ya que casi todo saldrá 0, aparte de algunas entradas que es poco probable que ingrese un ladrón. El código es un algoritmo simple, pero muy ofuscado (a mano).

Pip , 13 bytes

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

Pruébelo en línea (ingrese como Argumentos, no como Entrada).

JavaScript, 533 bytes, ¡Agrietado! 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)"));

No es mi ofuscación favorita mía, pero es un poco ordenado. Llamar como RESULT(inputs).

Podría otorgar una recompensa de +50 puntos si explica en detalle lo que está haciendo mi código junto con su crack. (No tienen que estar juntos, así que siéntase libre de FGITW si eso se adapta a sus caprichos).

Pyke, 3458 bytes, SEGURO , puntaje 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%)

Pruébalo aquí!

Hay algunos (30) 0x1bbytes que parecen haber sido comidos por SE.

Octava, 40 puntos. SEGURO

Respuesta ligeramente ofuscada a un desafío bastante popular.

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

Recomiendo probar esto en octave-online . Ideone no es tan bueno cuando se trata de STDIN.

Este fue el desafío del simulador de palanca 2015. Entrada en el formulario '123^32. La salida será -1 0 1para pesado a la izquierda, equilibrado y pesado a la derecha en ese orden.

Se ve así cuando está completamente golfizado :

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

Esto da salida -Inf, NaN, Infpara L, B, R respectivamente.

Haskell, SEGURO

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

Pruébalo en Ideone . "Uso":

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

En el desafío String Shenanigans, a uno se le da una cadena y dos caracteres y luego debe reemplazar cada aparición del primer personaje con el segundo. Sin embargo, la entrada es una cadena que solo contiene la cadena real entre comillas y los dos espacios en blanco separados por caracteres:

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

TeX, 240 bytes, SEGURO , puntaje 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

Guardar como jeopardy.tex, luego ejecutar pdftex jeopardy.texy abrir jeopardy.pdf.

Resultado: un PDF con el texto N(y la página número 1).

Python 3, agrietado!

Escribir esto fue divertido, a pesar de que al final fue fácil de descifrar :)

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

Si ayuda, Pyth no fue ninguna de las respuestas al desafío oculto.

u=.+G.*A

¡Pruébalo!

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, agrietado por daHugLenny

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

Pruébalo aquí!

C ++ 14, agrietado

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

Toma un número variable de parámetros y devuelve 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, Agrietado

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

Función nombrada ( ±).

Ruby, 50 bytes.

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

salida: 400

Python 2.7, 45 bytes

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

Sugerencia (o tal vez no): "el pez está usando numpy".

2016.11.23 - segunda pista: "¡No dejes nada flotando!"