PPCG Jeopardy: Policías

45

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

Este es un desafío de . 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: , , , , , , , . 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>

Nathan Merrill
fuente
1
No se requieren conteos de bytes.
Nathan Merrill
1
Existen muchos desafíos en los que las soluciones tomarán mucho más de una hora para calcular las entradas válidas. El límite de tiempo no es una buena idea.
Mego
2
@NathanMerrill La redacción actual sugiere que si existe una entrada que tomará una hora para calcular el resultado, la respuesta no es válida. Esto significa básicamente cada desafío no trivial.
un spaghetto el
44
@NathanMerrill No hay feersum aquí, pero como he comentado sobre el envío de Mego, no hay garantía de que no golpees otra colisión de hash antes de la prevista. Creo que los policías deberían tener la certeza de que su programa es el primero que coincide, en cuyo caso si el policía puede verificarlo, los ladrones también pueden hacerlo.
Sp3000

Respuestas:

11

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

DLosc
fuente
parece que está dividiendo una cadena en comas y devolviendo la segunda cadena en la división resultante O_O No sé pip, pero eso es todo lo que obtuve hasta ahora.
Yodle
2
@Yodle dividiéndolo en palabras regex, no solo en comas
Maltysen
Traducido a pyth, creo que esto es algo así como ht:w"\w+"1/ @:w"\w+"1 1, que minimiza a htcw/ htczsi solo importa el espacio en blanco, pero ninguno de ellos arroja ningún resultado. Además, esto podría extraer minutos del formato HH: mm: ss, o extraer un nombre de variable de una declaración de estilo C, o números después de un punto decimal. Pero no puedo encontrar preguntas que pidan alguna de esas cosas ...: /
Dave
3

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.

Gabriel Benamy
fuente
55
Como si Perl fuera más fácil de leer que un esolang: P
ETHproductions
1
Sí, no sé nada de esolangs, pero tampoco sé Perl :(
Yodle
Agrietado
DLosc
Dangit, iba a publicar exactamente eso hasta que la publicación se eliminó antes (tampoco pude encontrar la manera de ejecutarlo en ideone)
ETHproductions
Para cualquier entrada futura, enviaré un enlace ideone con una explicación de cómo ejecutarlo.
Gabriel Benamy
3

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!

Martin Ender
fuente
Este desafío probablemente no sea el que pretendía, porque la salida aquí cambia dependiendo de un número de entrada. Pero sin entrada, imprime la cadena en ese desafío, y "los ladrones necesitan encontrar cualquier desafío para el que el envío sea válido". Entonces, ¿agrietado?
Luis Mendo
@LuisMendo no imprime esa cadena.
Martin Ender
(Para ser claros, mi respuesta no imprime el seguimiento .requerido por ese desafío.)
Martin Ender
Sí, vi :-) Mi conocimiento de Hexagony no me permitió progresar mucho ...
Luis Mendo
Agrietada .
Stewie Griffin
3

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.


Explicaciones:

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)

Dada
fuente
3

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 , 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 ¡Es que nadie más tiene suficiente información para señalar fallas fáciles de solucionar en su respuesta!)

Comunidad
fuente
Seguro, me parece.
msh210
3

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.

Stewie Griffin
fuente
2

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.

Luis Mendo
fuente
Agrietado :-)
ETHproductions
@ETHproductions Oh, ¿cómo encontraste ese desafío? Lo elegí literalmente al azar .-)
Luis Mendo
2

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

Yodle
fuente
Lambda es Func<string, int, string>. Parece que es un cifrado de teclado. El parámetro número es cuántos caracteres se deben desplazar hacia la derecha en el teclado (es decir, ("t",1)= y).
leche
Agrietado
leche
Agradable, no esperaba que eso durara demasiado: P
Yodle
2

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!

Adnan
fuente
publicas
@tuskiomi Hmm, no, ese no fui yo.
Adnan
eso es extraño. Busqué en Google su resultado (debe asegurarse) y ese fue 1 de 3 resultados. Me pregunto si hay un bot que está sacando respuestas. hmm ..
tuskiomi
Imprime la segunda entrada
Oliver Ni
1
agrietado ?
Maltysen
2

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

Mega Man
fuente
Ahora, ni siquiera entiendo ese código para mí ...
Mega Man
1
Es fácil desofuscar, pero las preguntas que podrían encajar parecen etiquetadas como castores ocupados ...
Peter Taylor
Buena ofuscación!
OldBunny2800
Esto se calcula 9**99sin imprimir nada (también lleva mucho tiempo hacerlo)
Azul
@ PeterTaylor No es una pregunta de castores ocupados, simplemente tomé una forma extraña de resolver la pregunta.
Mega Man
2

Rubí ( agrietado por DLosc )

p n = gets.to_i
p n = n*(3*n-1)/2 until n % 7 == 0
histocrat
fuente
Vaya, me perdí el primero pcuando copié el código. Agrietado , entonces.
DLosc
2

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.

Luis Mendo
fuente
Pruébelo en línea por favor.
tuskiomi
@tuskiomi Hecho. Pero como tienes que adivinar el formato de entrada, no sirve de mucho ...
Luis Mendo
Los números parecen funcionar bien.
tuskiomi
Agrietado !
boboquack
2
Esto podría ser un ganador ... :)
Stewie Griffin
2

CJam ( seguro , 21 puntos)

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

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

Peter Taylor
fuente
2

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

FlipTack
fuente
1

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

Conor O'Brien
fuente
1

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.

Azul
fuente
puedes marcar esto como seguro ahora
FlipTack
1

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.

Stewie Griffin
fuente
1
¿Por qué editó Oliver en el conteo de bytes? esto no es codegolf, y la respuesta no tiene que ser competitiva para el desafío, solo válida
FlipTack el
1

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!"
Laikoni
fuente
1

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


fuente
0

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)
FlipTack
fuente
mensaje codificado en base64:(sum([x%4<1 for x in range(min(D),max(D))]))
Azul
sí, solo lo tiré por diversión @BlueEyedBeast
FlipTack
Por alguna razón. sustituir esa cadena decodificada me da un TypeError>.>
Yodle
@Yodle ¿Funciona el código original? Si es así, solo asegúrese de sustituir la cadena decodificada correctamente
FlipTack
Sí lo hace, por eso estoy muy confundido jaja. Estoy bastante seguro de que lo estoy haciendo bien, simplemente eliminando base64decode (...). Decode () con la cadena ¿verdad?
Yodle
0

Pyth - Agrietado por Maltysen

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

u=.+G.*A

¡Pruébalo!

Steven H.
fuente
agrietado ?
Maltysen
¡Agrietado! Eso fue rápido.
Steven H.
0

C #, 91 bytes

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

Mathematica, 161 bytes

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

BrainFuck - 140 Bytes, agrietado por daHugLenny

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

Pruébalo aquí!

FinW
fuente
1
Agrietado
acrolith
0

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;
}
Karl Napf
fuente
El título dice C ++ 14, por lo que necesita al menos g++y si su versión no es al menos 6.2o algo que necesita-std=c++14
Karl Napf
1
Agrietado
Peter Taylor
0

Mathematica, 34 bytes, Agrietado

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

Función nombrada ( ±).

JungHwan Min
fuente
No puedo decir si es esto y usted pasó por alto la regla "No hay dígitos del 0 al 9 para que aparezcan en el código", o si es esto y decidió tomar una entrada unaria para la ofuscación.
Martin Ender el
Vaya, es el primero, pero me perdí totalmente esa regla ...
Cambiaré
Agrietado entonces. ;)
Martin Ender
0

Ruby, 50 bytes.

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

salida: 400

dkudriavtsev
fuente
Agrietado.
Martin Ender el
0

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

en cualquier lugar
fuente
¿Son las tres entradas estrictamente necesarias? ¿Podría esto funcionar si codificas una (o más) de las entradas?
Stewie Griffin
@StewieGriffin Sí. Las preguntas requieren explícitamente tres entradas; tanto en el texto como en los casos de prueba.
agtoever