Este es el hilo conductor de la policía. El hilo de los ladrones va aquí .

Escriba un programa o función que consista solo en caracteres ASCII imprimibles (que excluye tabulación y nueva línea) que muestre al menos 5 caracteres ASCII imprimibles en orden ascendente (desde el espacio hasta la tilde / 32 a 126). Los caracteres se pueden generar varias veces, siempre que estén adyacentes entre sí. Se acepta una nueva línea final. Debe proporcionar la salida completa, y por cada 6 caracteres en su código debe proporcionar un carácter en su código, en la posición en que aparece. Si su código tiene 5 o menos caracteres, debe revelar solo la longitud. No revelarás más de 1 carácter por cada 6 en tu código.

Entonces, si su código alphaprintergenera el alfabeto desde az, entonces necesita revelar 2 caracteres de su código (use guión bajo para los otros), por ejemplo:

al__________  // or
__p__p______  // or
__________er

Reglas / especificaciones:

• No puede agregar espacios en blanco finales que no tienen una función.
• No puede usar comentarios (pero los ladrones pueden usar comentarios al descifrar el código)
• No se permiten primitivas criptográficas incorporadas (incluye rng, cifrado, descifrado y hash).
• En los idiomas en los que la salida predeterminada es como en MATLAB:, ans =eso se acepta, siempre que se indique claramente y se muestre que ans =se emite. También debe establecerse claramente si esto es parte de la "salida ascendente" o no.
• La salida debe ser determinista
• No se acepta el uso de un lenguaje no libre
• La salida no tiene que ser caracteres consecutivos. Ambos abcdey abcdgson salidas válidas.
• Los caracteres no necesitan ser distintos siempre que la salida contenga al menos 5 caracteres. aaaaay aaaccson validos
• Las respuestas que asumen un entorno REPL no se consideran programas o funciones válidas y, por lo tanto, no están permitidas.
• STDERR no se considera salida válida, pero los datos pueden escribirse en STDERR.

Si los caracteres revelados son guiones bajos, debe identificarlo como se muestra a continuación. En este caso, los caracteres segundo y sexto se revelan con guiones bajos, mientras que los otros son desconocidos.

_____________
 |   |

Nota: Los ladrones solo necesitan encontrar un código que produzca la misma salida. El idioma, la duración de la solución de los ladrones y la posición de los personajes revelados también deben coincidir.

Su puntaje es el número de caracteres en su código. El ganador será la presentación con el puntaje más bajo que no se haya descifrado en 7 días. Solo los envíos publicados en 2015 (UTC) son elegibles para la victoria. Las presentaciones que se publiquen después de esto son bienvenidas, pero no pueden ganar.

Para reclamar la victoria, debe revelar el código completo (después de 7 días).

Su publicación debe tener el siguiente formato (nn es el número de caracteres):

Idioma, nn caracteres

Salida:

abcdefghijklmnopqrstuvwxyz

Código (12 caracteres):

al__________

Si el código está descifrado, inserte [Cracked] (enlace al cracker) en el encabezado. Si el envío es seguro, inserte "Seguro" en el encabezado y muestre el código completo en su respuesta. Solo las respuestas que hayan revelado el código completo serán elegibles para la victoria.

Hexagonía , 8 caracteres, caja fuerte

_______.

huellas dactilares

123456

Puedes probar Hexagony en línea

Solución

`&)!."@.

El `es simplemente mala dirección para hacer la mirada código como se requiere lado de longitud 3. A menos que el intérprete se ejecuta con -del acento grave se pela simplemente a partir del código fuente antes de determinar la disposición. Luego, el código se ajusta a la longitud lateral 2:

 & )
! . "
 @ .

Esto mueve el puntero de memoria (MP) alrededor de un hexágono de la cuadrícula de memoria, mientras copia el valor al siguiente borde, incrementándolo e imprimiéndolo.

Así es como se ve la cuadrícula de memoria, con el MP comenzando la posición marcada:

Inicialmente, todas las aristas son cero. El primero &es un no-op, pero )incrementa el borde e !imprime el 1. Luego se "mueve hacia la izquierda (el borde etiquetado como 2 ). Allí, &copia un valor. Como el borde es actualmente cero, se copiará el vecino izquierdo (en la dirección del MP), que es el 1que acabamos de imprimir. )lo incrementa, !imprime el 2. Esto continúa mientras visitemos nuevos bordes e imprimamos todos los dígitos hasta 6. Cuando lleguemos al borde en el que comenzamos, &copiaremos el vecino correcto en su lugar (porque el valor del borde es positivo), por lo que el borde se 0vuelve a hacer y el flujo de control salta a la última fila,@ termina el programa

Pruébalo en línea.

Perl, 46 caracteres (seguro)

Salida:

((()))*++,---../00011123445556667779::;;<<==??@@AAACEFGHHHIKKMMNOOOPPQQQRRSSSVWXXYY[[[\]]]^^^```aaeeffggghjjjnpppqqrttuwxxyzz{{{

Código:

print _______________________________________;

De alguna manera logré eliminar el original en el espacio de una semana, pero creo que esto es correcto:

print chr()x(($i=($i*41+7)%97)&3)for(40..123);

Brainfuck, 48 personajes, descifrado por Mitch Schwartz

Hice este para los ladrones. Definitivamente no será la presentación ganadora :)

____[_____[_______]__]___[___________]___[_____]

Esto produce:

ABCDEFGHIJKLMNOPQRSTUVWXYZ

Solución:

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

Lo probé aquí .

Sugerencia: no intente encontrar programas generados por generadores en línea jaja. Esto fue escrito a mano y solo se puede resolver mediante el pensamiento lógico :)

CJam, 13 personajes

_____________
  ||

huellas dactilares

7LLMYahnsuv

Puedes probar CJam en línea.

Solución

{`__Jf^er$}_~

Pensé que basar a un policía en una quine generalizada era bastante inteligente y novedoso. En el momento en que publiqué esto, me di cuenta de eso __y soy ercompletamente inútil, por eso publiqué al policía de 8 bytes de CJam para obtener una puntuación más competitiva. Pietu resolvió eso bastante rápido, así que tuve miedo de que él también lo descubriera. Supongo que la transliteración de caracteres innecesariamente complicada lo salvó.

De todos modos, el código toma sus propios caracteres (excepto el _~), XOR cada uno con 19 para ofuscación y luego los ordena.

Este policía me llevó al "descubrimiento" de xorting , aunque en realidad no lo estoy usando aquí (y probablemente sería casi imposible usarlo con una breve quine generalizada).

Ruidoso 3SP , 89 caracteres (seguro)

0 _____________________________ _ _ _ _ _ _ _ _ _ __2_2__________________________________

Programa original:

0 0 0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 0 3 2 2 2 2 0 3 0 1

Este programa imprime

 !"#$$

(tenga en cuenta el espacio inicial), y nada más!

Explicación (* n se refiere a la enésima celda en la memoria):

0 0 0                                Increment *0 to 3 (via the 0s in *0, *1, and *2)
2 (32 times)                         Increment *3 to 32 (via the 0 in *2 and the 3 in *0)
                                      (Note that *3 mod 256 is the character that prints)
0                                    Increment *32 (via the 3 in *0 and the 32 in *3)
3                                    Increment *1 (via the 32 in *3 and the 1 in *32)
                                      (Note that printing is on when *1 mod 2 is 1,
                                       which means " " prints right here)
2 (4 times)                          Increment *3 to 36 (printing '!"#$')
0                                    Increment *36 (via *3) (printing "$" again)
3                                    Increment *1 to 2 (via *36) (printing turns off)
0                                    Increment *36 to 2 (via *3)
1                                    Increment *0 to 4 (via *2)

Los dos últimos comandos resultan ser suficientes para evitar que 1 se incremente nuevamente en pasadas posteriores a través del programa, lo que significa que nunca más se imprimirá, aunque continuará configurando todas las direcciones de memoria desde * 36 en adelante hasta el valor 36 para siempre .

JavaScript (ES6), 60 caracteres, descifrado por el usuario 81655

No promete ganar, pero espero que sea divertido de descifrar:

e_e_______a__a____e___e________e__o___________o______o______

Esta es una función que devuelve:

    :ERacddeeeeeeffiinnnoorrrrst
^^^^ -> 4 whitespaces

Editar

user81655 lo descifró carácter por carácter:

e=e=>{try{a}catch(e){return[...e.toString()].sort().join``}}

Matlab Octave, 27 caracteres, caja fuerte

Reto

En cuanto a las nuevas restricciones de idioma: también funciona en Octave.

____________3_3___4_3______

Salida (en octava): ( ans =no es parte de la salida, el primer carácter de la salida es ")

ans = """""""""""""""""""""""""""""""""""""""""""########$$$$$$%%%%&&&&'''(()))**++,,-../001223456789:;<=>?@BCDFGHJKMNPRTUWY[]_acehjloq

Salida (en Matlab): ( ans = \n\nno es parte de la salida, la salida es solo la última línea)

ans =

"""""""""""""""""""""""""""""""""""""""""""########$$$$$$%%%%&&&&'''(()))**++,,-../001223456789:;<=>?@BCDFGHJKMNPRTUWY[]_acehjloq

Solución

[fix((0:.07/3:3).^4+34),'']

Básicamente estamos viendo esta función, convertida a valores ASCII.

R, 60 bytes, agrietado por plannapus

Salida:

0123456789ABCDEFGHTUVWXYZdefghijklmnopqrstuvw

Código:

___(_(_:_____________]_____________6]_______s_4_____,___=___

Creo que esto no será tan difícil. Veremos.

Jolf , 27 personajes, Agrietado por Adnan

________W___________--_____
                         |

huellas dactilares

abcdefghijklmnopqrst

Intérprete .

Código original:

on*2toHEWn)oH+H `pl$--$n}_H
on                          set n
  *2t                        to twenty
     oHE                    set H to the empty string
        Wn)                 while(n){
           oH+H             append to H
                `pl$--$n     get the nth character of the alphabet, decrement n before
                        }   }
                         _H print H reversed

¡Felicidades a Adnan! Me asustas.

Aquí puede probar su envío para ver cuántos caracteres deben eliminarse.

setInterval(function(){r=document.querySelector("textarea").value;document.getElementById("output").innerHTML=r.length/6-r.split("").filter(function(x){return x=="_"}).length|0},20)

*{font-family:Consolas,monospace}textarea{width:100%;resize:none;height:auto;min-height:1.2em;}b{color:red;}

<textarea>Example Program</textarea><div>You must reveal <b id="output">n</b> characters.</div>

Fortran, 45 caracteres, caja fuerte

Salida completa:

 !"$)0<Ka|

Cat intentó descifrarlo aquí

Código (45 caracteres):

pr_gr_m____________________/___3____________

Código de programa:

program t;print*,(char(i**3/8+33),i=1,9);end

PHP, 46 caracteres, seguro

Fuente:

for(_______________________=________________);

Emite una cadena larga de 84 caracteres:

!!"#$%&'()*+,-./0123456789::;<=>?@AABCDEEFGHIIJKLLMNNOPPQRRSTTUUVWWXXYYZZ[[\\]]^^__`

Insinuación

¿Qué dirías? Mi primo está involucrado?

Código revelado

Este método es relativamente simple, ya que imprime hasta 64 caracteres a partir de chr(32). La parte oculta es que el iterador ino se incrementa linealmente. Se incrementa en su propio valor de coseno que dará como resultado caracteres repetidos y faltantes.

for(;$i<64;)echo chr(32+$i+=cos(deg2rad($i)));
for(_______________________=________________);

CJam, 8 bytes, Craqueado por Pietu1998

__:_____

huellas dactilares

%*;a|~

Puedes probar CJam en línea .

05AB1E , 13 caracteres, descifrados por quintopia

Soy un idiota. Olvidé implementar la función de potencia (-_-｡). Aquí está el código ofuscado:

__D____<_____

Mi código original fue:

99DF2}r<F*}bR

Explicación:

99DF2}r<F*}bR

99            # Pushes 99
  D           # Duplicates the top item
   F }        # Creates a for loop: For N in range(0, 99)
    2         # Pushes 2 (this will be done 99 times)
      r       # Reverses the stack
       <      # Decrement on the last item
        F }   # Creates a for loop: For N in range(0, 98)
         *    # Multiplies the last two item of the stack, which now looks like
              # [2, 2, 2, 2, 2, 2, 2, 2, ...]. Basically we're calculating 2^99
           b  # Converts the last item to binary
            R # Reverses the last item of the stack

Esto generará:

0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

Sí, eso es 99 ceros seguidos de un 1.

Tenga en cuenta que tengo una función de potencia implementada en este momento. Entonces esto podría hacerse en seis bytes:

Y99mbR

Python 3.4, 127 caracteres

Esta es mi primera publicación de cobre. Creo / espero que no sea demasiado difícil ni demasiado obvio.

El código ofuscado:

_______inspect__________________getsource_____________________________________________print__________c*s_______________________

crea esta salida (hay 5 espacios al principio; la longitud total es 7740 caracteres):

     """"""""""""(((((((((((((((((((((((((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))**********************...................................................................................................................;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;==============================[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooopppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppprrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrsssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Pyth, 17 caracteres, descifrado por Pietu1998

Salida:

""''''''''''''''''''''0000000000111111111122222222223333333333XXXXXXXXXX[[[[[[]]]]]]

Código:

___________#____1

Mi solución:

Sjkm^dT%"'%#X"291

La solución de Pietu1998:

S`u]G6*T`t"#X0231

Malbolge, 254 caracteres, descifrado por Adnan

Código:

_____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ __

Salida:

`AB\cd`

Hice un poco de trampa al poner un espacio para cada sexto personaje. Oh bien...

El código descifrado de Adnan:

('&%: ^"!65 4Xzyx w4-Qs rpo'K mlk"' ~Dfdc ba}v< ::8[Z XnVlq }0/mO ,*MbK JH^6# 4`C|0 ?U=Sw uPsaq L4on2 Mjjh, ged)c '<$$p ]!};Y WiVxS eRQ>= ).K]l Ij"Fh gfedc b,=;z L\q%H X3E2C /ng-k N*KJI 8%6#D ~2^Ai >g<<d tUr`6 oJ"!1 /|{CU f)d>b <A_^! \};Yj yUxTS dtsr` ML

El código original:

bCBA@ ?>=<; :9876 54321 0/.-, +*)(' &%$#" !~}|{ zyxwv utsrq ponml kjihg fedcb a`_^] \[ZYX WVUTS RQPON MLKJI HGFED CBA@? >=<;: 9y165 43210 /.-,+ *)('& }C#"! ~wv<z \xwvu tsrqp onmlk jihgf e^$ba `_^W\ UyYXW VUTSR QPONM FKJIH GFEDC BA@9] =<;:9 27654 3210) M:

Hice trampa nuevamente usando un generador de texto a Malbolge para este código.

Mathematica 10.1, 98 caracteres, seguro

La salida está aquí. . La salida completa tiene 838,316 caracteres y una nueva línea final.

Código:

Print[""<>Chara__________________________________________________________________________________]

Sí, esto debe ejecutarse en 10.1. _(pista) El programa original:

Print[""<>Characters@ToCamelCase@ExampleData@{"Text","DonQuixoteIEnglish"}~SortBy~ToCharacterCode]

MATL , 8 caracteres, caja fuerte

Se espera que la versión estable del compilador que trabaja en Octave llegue pronto. Mientras tanto, esta confirmación de GitHub funciona y, en particular, ejecuta el código original que produce el resultado indicado

Esta presentación cuenta como se publicó el 28 de diciembre de 2015 a las 15:30 UTC

Salida:

$**0016688??@HHQ

Código (8 caracteres):

_:______

Solución

6:9tX*Sc

Que hace:

6:9          % numeric vector [6 7 8 9]
t            % duplicate
X*           % Kronecker tensor product
S            % sort in ascending order 
c            % convert to char. Implicit display

Laberinto , 5 bytes, Agrietado por Adnan

_____

huellas dactilares

000000

Mi código original fue:

<!!@ 

Tenga en cuenta el espacio final.

Supongo que debería haber elegido más personajes y haber revelado uno de ellos !, porque la solución de Adnan solo crece linealmente al agregar más !, mientras que la mía crece de forma cuadrática.

PHP, 28 caracteres

<?=________________________;

Emite la cadena

abcdefghijklmnopqrstuvwxyz

ES6, 17 caracteres, descifrado por Cᴏɴᴏʀ O'Bʀɪᴇɴ

__=____=_________

Esta es una función que devolverá la cadena

11233

JavaScript, 83 caracteres, descifrado por Martin Büttner

Salida

Hi~~~

Código

_=____r____=u____=__s__=_________=__________________u_______A__________e______"_~_"

La salida está en la consola JS de un navegador como Chrome / Firefox.
Código original (que puede no ser válido):

q=w=e=r=t=y=u=i=o=p=s=d=f=g=h=j=k=l=z=x=c=v=b=n=m="Huh"[0]+"Alarms in here"[7]+"~~~"

Pyth, 6 personajes, descifrado por Pietu1998

Código:

S_____

Salida:

.0113345678888999

Puedes probar Pyth aquí

JavaScript ES6, 134 caracteres

Huh chico, eso fue divertido. ¡Buena suerte!

_=_=_____l____.______.________(___}__;___=______ru____"_____+_[________]______!____]__[_________e________.__U_________)__________\_____

Salidas:

((((((()))))))+...000000000000000000002233=>AAAAAAAAAAABBBBBCCCCCCCCCCCCCCCCCCDDDDDDDEEEEEEEEEEEEEEEEEEEFFFFFFFGHIIIIIIIIIIIIIIIIJJJJLLMMNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOPRRRRRRRSSSSTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUVVVVVVXXY[[[[[[[[]]]]]]]]````ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiinnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu{{{{{{}}}}}}

CJam, 12 personajes, Cracked by jimmy23013

Salida

#$%&'()*+,-./:;<=>?@[\]^_`

Código

_:____#_____

En serio , 7 bytes, descifrado por Martin Büttner

______S

Salida:

   deeknnoow

No debería ser demasiado difícil, incluso si el resultado no es exactamente lo que esperarías.

Python 3, 58 caracteres, descifrado por Mitch Schwartz

Código:

______________print(_______(_______________________)_____)

import string; print (''. join (sorted (string.printable)) [5:])

Salida:

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Befunge, 11 personajes, agrietados (en funge-98) por MegaTom

Salida:

1223788

Código ofuscado:

________.__

Todas una línea, ya que las reglas prohíben las nuevas líneas. Probado con http://www.quirkster.com/iano/js/befunge.html .

Editar: Esto está legalmente descifrado ya que no especifiqué una versión, pero tenga en cuenta que todavía hay una solución Befunge-93.

Perl 5, 30 bytes, descifrado por Adnan

Código:

print_________________________

Salida:

9:;@AFGHLMNRSTYZ_`a

Agrietado:

Adnan encontró una grieta trivial : obviamente, no pensé en este acertijo lo suficientemente bien. He compuesto otro en su lugar.

Python 2, 62 caracteres, Agrietado por Adnan

______________________________________________________________
         | |   ||                  |  |  ||

Se parece un poco a una mesa.

Esto genera la cadena abcde.

Código de Adnan:

print "ab_c_de___".replace("_","")#___________________________

Mi código:

f=lamda _,__,___:"abcde"+'f'*sum(_,__,___)*000;print f(1,2,3);