Nota: este desafío está terminado. Las presentaciones son bienvenidas pero no pueden ganar.

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

Escriba un código que genere el entero 1. Si agrega, elimina o sustituye un solo carácter (de su elección), el código debería generar el entero 2. Cambie un carácter más (el mismo u otro), y el código debería salir 3. Continúe así todo lo que pueda, pero hasta un máximo de 10. Formatos de salida predeterminados como ans = 1los aceptados. Puede ignorar la salida a STDERR (o equivalente).

Debe revelar el idioma, el recuento de bytes de su código inicial, la cantidad de enteros para los que funciona, así como una cantidad opcional de caracteres del código inicial. Nota: No tiene que revelar ningún personaje, pero recuerde que revelar personajes podría dificultar a los ladrones, ya que deben usar el mismo personaje en la misma posición. Puede elegir qué carácter usar para denotar caracteres no revelados (por ejemplo, subrayado), pero asegúrese de especificar esto.

Los policías pueden proporcionar el código no descifrado después de una semana y llamar al envío "SEGURO". El envío ganador será el envío sin descifrar más corto que produce el número 10. Si no hay envíos sin descifrar capaces de imprimir 10, el código más corto que produce 9 ganará, y así sucesivamente. Tenga en cuenta que los ladrones no tienen que hacer los mismos cambios que usted, y no tienen que reproducir el código exacto (a menos que revele todos los caracteres). Solo deben reproducir la salida.

Las presentaciones publicadas después del 24 de noviembre son bienvenidas pero no son elegibles para la victoria (porque probablemente habrá menos ladrones).

Publicación de ejemplo:

La siguiente publicación es una presentación en el idioma MyLang, tiene una longitud de 9 bytes y funciona para los números 1 a 8.

MyLang, 9 bytes, 8 números

Esta presentación funciona durante 1 - 8. No Revelados caracteres se indican con un guión: _.

abc____i

Tabla de clasificación

Descargo de responsabilidad: la tabla de clasificación no se prueba y es posible que los envíos no descifrados no aparezcan en la lista.

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><style>table th,table td{padding: 5px;}th{text-align: left;}.score{text-align: right;}table a{display: block;}.main{float: left;margin-right: 30px;}.main h3,.main div{margin: 5px;}.message{font-style: italic;}#api_error{color: red;font-weight: bold;margin: 5px;}</style> <script>QUESTION_ID=99546;var safe_list=[];var uncracked_list=[];var n=0;var bycreation=function(x,y){return (x[0][0]<y[0][0])-(x[0][0]>y[0][0]);};var byscore=function(x,y){return (x[0][1]>y[0][1])-(x[0][1]<y[0][1]);};function u(l,o){jQuery(l[1]).empty();l[0].sort(o);for(var i=0;i<l[0].length;i++) l[0][i][1].appendTo(l[1]);if(l[0].length==0) jQuery('<tr><td colspan="3" class="message">none yet.</td></tr>').appendTo(l[1]);}function m(s){if('error_message' in s) jQuery('#api_error').text('API Error: '+s.error_message);}function g(p){jQuery.getJSON('//api.stackexchange.com/2.2/questions/' + QUESTION_ID + '/answers?page=' + p + '&pagesize=100&order=desc&sort=creation&site=codegolf&filter=!.Fjs-H6J36w0DtV5A_ZMzR7bRqt1e', function(s){m(s);s.items.map(function(a){var he = jQuery('<div/>').html(a.body).children().first();he.find('strike').text('');var h = he.text();if (!/cracked/i.test(h) && (typeof a.comments == 'undefined' || a.comments.filter(function(b){var c = jQuery('<div/>').html(b.body);return /^cracked/i.test(c.text()) || c.find('a').filter(function(){return /cracked/i.test(jQuery(this).text())}).length > 0}).length == 0)){var m = /^\s*((?:[^,;(\s]|\s+[^-,;(\s])+).*(0.\d+)/.exec(h);var e = [[n++, m ? m[2]-0 : null], jQuery('<tr/>').append( jQuery('<td/>').append( jQuery('<a/>').text(m ? m[1] : h).attr('href', a.link)), jQuery('<td class="score"/>').text(m ? m[2] : '?'), jQuery('<td/>').append( jQuery('<a/>').text(a.owner.display_name).attr('href', a.owner.link)) )];if(/safe/i.test(h)) safe_list.push(e);else uncracked_list.push(e);}});if (s.items.length == 100) g(p + 1);else{var s=[[uncracked_list, '#uncracked'], [safe_list, '#safe']];for(var i=0;i<2;i++) u(s[i],byscore);jQuery('#uncracked_by_score').bind('click',function(){u(s[0],byscore);return false});jQuery('#uncracked_by_creation').bind('click',function(){u(s[0],bycreation);return false});}}).error(function(e){m(e.responseJSON);});}g(1);</script><link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/Sites/codegolf/all.css?v=7509797c03ea"><div id="api_error"></div><div class="main"><h3>Uncracked submissions</h3><table> <tr> <th>Language</th> <th class="score">Score</th> <th>User</th> </tr> <tbody id="uncracked"></tbody></table><div>Sort by: <a href="#" id="uncracked_by_score">score</a> <a href="#" id="uncracked_by_creation">creation</a></div></div><div class="main"><h3>Safe submissions</h3><table> <tr> <th>Language</th> <th class="score">Score</th> <th>User</th> </tr> <tbody id="safe"></tbody></table></div>

Hexagonía , 18 bytes, 10 números, SEGURO

Esta presentación funciona durante 1 - 10. No Revelados caracteres se indican con un guión: _.

.__{_]5[$@.;=@$!!1

Puedes probar Hexagony en línea aquí.

Mi solución:

1:   .<[{8]5[$@.;=@$!!10
2:   .<[{8]5[$@);=@$!!10
3:   2<[{8]5[$@);=@$!!10
4:   3<[{8]5[$@);=@$!!10
5:   4<[{8]5[$@);=@$!!10
6:   5<[{8]5[$@);=@$!!10
6:   7<[{8]5[$@);=@$!!10
8:   7<[{8]5[$@);=@$!!10
9:   8<[{8]5[$@);=@$!!10
10:  9<[{8]5[$@);=@$!!10

Hex para la salida 1:

Pruébalo en línea!

Full Hex:
  . < [ 
 { 8 ] 5
[ $ @ . ;
 = @ $ ! 
  ! 1 0

Important parts:
  . < .
 . 8 . 5
. $ @ . ;
 . . $ .
  . 1 .

1. En el <borde de la memoria está 0, entonces aparece.
2. Golpes 1
3. Salta a 5
4. Salta 8, pero se invierte <y recupera 8el camino.
5. Golpea de 5nuevo
6. Salta sobre 1
7. Golpea el <en este punto, el valor de la memoria es 1585 que, mod 256, resulta ser ASCII1
8. Finalmente imprime y sale con ;@.

Hex para la salida 2:

Pruébalo en línea!

Important parts:
  . < .
 . 8 . 5
. $ @ ) ;
 . . $ .
  . 1 .

Esto sigue el mismo camino, pero en el camino de regreso golpea uno )que incrementa el borde de la memoria a 1586, o 2.

Hex para la salida 3-9:

Pruébalo en línea!

Important parts:
  2 < [
 . . ] .
. $ . ) .
 . @ . !
  . 1 .

1. Golpea el 2
2. Ahora el borde de la memoria es positivo cuando llega <, por lo que se rechaza.
3. El ]cambia el puntero de instrucción, pero se viene inmediatamente de nuevo con[
4. ) incrementos a 3
5. ! Huellas dactilares 3
6. $queda de los dos primeros números, así que saltamos al final ( @)
7. 1 cambia el borde de la memoria, pero eso no importa ahora.
8. < refleja el puntero hacia atrás.
9. Nuevamente 1no importa porque presionamos @para finalizar el programa.

Retina , 2 bytes, 10 números, agrietados

_1

Funciona de 1 a 10, _es un personaje oculto. Esto no debería ser demasiado difícil, pero espero que proporcione un rompecabezas algo interesante. :)

Puedes probar Retina en línea aquí.

Octava, 55 bytes, 10 números, agrietados

(o__(O_o_(@(__o)o__-O}_)_(0<O,{_(_o_O-1)+1_@(_1}_)(__o_

_ Es el personaje desconocido.

Solución

(o=@(O,o)(@(O,o)o{2-O}())(0<O,{@()o(O-1)+1,@()1}))(0,o)% luego cambiando el último 0a 1,2,3etc.

Dado x, esto se calcula recursivamente x+1. Se compone principalmente de dos funciones anónimas. Uno proporciona una ifdeclaración para anclar la recursividad:

if_ = @( boolean, outcomes) outcomes{ 2 - boolean}();

esto es solo abusar del hecho de que los valores booleanos se evalúan en 0o 1. Esta función acepta un valor booleano y una matriz de celdas de dos funciones, y evalúa una u otra de estas dos funciones dependiendo del valor booleano. La segunda parte es la recursión real:

plus_one = @(n,f) if_(0<n ,{@()f(n-1)+1, @()1})

como una función anónima es anónima, no puede acceder directamente desde itsefl. Por eso necesitamos un segundo argumentofprimero. Más adelante proporcionaremos un identificador a la función en lugar de un segundo argumento, por lo que una función final se vería así:

plus_one_final = @(n)plus_one(n,plus_one);

Entonces, en esta notación, mi presentación se convierte en:

(plus_one=@(n,f)(@(boolean,outcomes)outcomes{2-boolean}())(0<n,{@()f(n-1)+1,@()1}))(n,f)

pregunté acerca de los anclajes de recursión para funciones anónimas en MATLAB hace un tiempo en stackoverflow .

Python 2, 9 bytes, 10 números, agrietados

print 8/8

No hay caracteres ocultos. ¿Puedes romperlo sin forzarlo?

Perl, 12 bytes, 10 números, ¡Agrietado!

Los guiones bajos representan caracteres desconocidos.

____;say__-9

Probablemente bastante fácil, y no me sorprendería si hubiera múltiples soluciones. Aún así, puede ser divertido crackear.

(La solución prevista era la misma que la grieta. Esto es fundamentalmente un problema sobre la asignación de 10 a una variable en cuatro caracteres, lo cual es sorprendentemente difícil en Perl; a diferencia de muchos idiomas de golf, no tiene una variable que comience de manera útil en 10.)

Perl, 46 bytes, 10 números, caja fuerte

El problema

__b_b_\__}_b_b_b_0_;
$b[0]=10;$b{0}=1;say$b[0]

Los problemas más cortos tienden a resolverse rápidamente, así que pensé en probar uno más largo. Los más largos también tienden a resquebrajarse si las personas dejan un espacio suficiente para escabullirse de algo travieso sayo exitadentro, por lo que todas las brechas aquí son cortas. Los caracteres ocultos se representan usando _.

Mi solución

sub b{\@_}*b=b$b{0};
$b[0]=10;$b{0}=1;say$b[0]

Para imprimir 2, 3, etc., hasta 9, siga cambiando el número asignado a $b{0} en la segunda línea (es decir $b{0}=2, $b{0}=3, etc.). El programa para 9 se ve así:

sub b{\@_}*b=b$b{0};
$b[0]=10;$b{0}=9;say$b[0]

Luego, para producir 10, comente la primera línea anteponiéndole un #carácter.

Explicación

Lo primero que hay que tener en cuenta es que la solución no está realmente separada de la eliminación de espacios en blanco: si lo diseñamos con espacios en blanco más legibles, obtenemos esto:

sub b { \@_ }
*b = b $b{0};
$b[0] = 10;
$b{0} = 1;
say $b[0];

Normalmente, cuando accede a los argumentos de una subrutina en Perl, lo hace copiando de ellos @_. Hay una buena razón para esto:@_ alias los argumentos que se le da a la subrutina (por lo que, por ejemplo, (sub { $_[0] = 3 })->($x)se asignará $x), algo que normalmente no es deseable.

Aunque @_pueda parecer mágico, en realidad solo está usando una característica estándar de las partes internas de Perl (que está disponible fácilmente en XS pero solo aparece en algunos casos extraños en Perl puro, como él @_mismo): una matriz no almacena sus elementos directamente , sino más bien por referencia. Por lo tanto, cuando llamamos ba la segunda línea a continuación, Perl genera una matriz (llamándola @_) cuyo primer elemento es una referencia al mismo almacenamiento que$b{0} usa. (Los valores de hash también se almacenan por referencia; $ _ [0] y $ b {0} hacen referencia al mismo almacenamiento en este punto). Debido a @_que no está haciendo nada especial desde un punto de vista interno, podemos tomar una referencia al igual que podríamos con cualquier otra matriz, lo que hace que sobreviva a la subrutina en la que se define.

Las variables de Perl también se refieren al almacenamiento de datos por referencia. Hace mucho tiempo, la gente solía usar código como *x = *y;establecer $xcomo un alias para $y(haciendo referencia a lo mismo), del mismo modo @xcomo un alias para @y, %xcomo un alias para %y, y así sucesivamente. Eso más bien rompe la invariante de que las variables con nombres similares no tienen que actuar de manera similar, por lo que Perl moderno ofrece una alternativa; asignar una referencia a un typeglob anula solo la variable que coincide con el tipo de referencia (por *x = \%ylo que sería un alias %xpara apuntar al mismo almacenamiento %ypero dejar, por ejemplo, $xsolo). En particular, a esta sintaxis no le importa si el almacenamiento alias al que tiene un nombre, por lo que cuando asignamos el valor de retorno deb(que es una referencia de matriz que mantiene @_viva la matriz anteriormente llamada ) *b, lo que sucede es que @bse cambia a alias de la lista de argumentos de la llamada a b(sin dejar %bcambios). Esto significa, en particular, que $b[0]y $b{0}ahora apuntan al mismo almacenamiento, y la asignación a uno, por lo tanto, cambiará al otro. Todo a partir de entonces es completamente sencillo.

La documentación de Perl en realidad no habla de este tipo de detalles, así que no me sorprende que alguien haya entendido; la naturaleza de @_no ser como otras matrices no es algo que realmente se enfatice, y la mayoría de los estilos de codificación apuntan a minimizar los efectos que esto tiene en lugar de amplificarlos.

JavaScript, 30 bytes, 10 números, agrietados

alert(Array(_)________.length)

No debería ser demasiado difícil, pero espero que sea lo suficientemente difícil como para proporcionar un desafío. :) Los caracteres no revelados están marcados con _.

Perl, 14 bytes, 10 números, Agrietado

say_!"___"%""_

Funciona de 1 a 10. _son personajes ocultos.

Creo que esto no debería ser demasiado difícil de descifrar. Tengo uno más difícil, para 22 bytes, lo publicaré si este está roto.

say"!"=~y"%""c

Y reemplace el "!"por una cadena de la longitud del número que desea imprimir, por ejemplo !,!! , !!!, etc.

Sin embargo, ais523 encontró otra forma:

say"!"+1#"%""r

JavaScript, 22 bytes, 10 números, agrietados

Probablemente bastante fácil de descifrar.

alert(__14_337__xc_de)

_ ser un personaje oculto

Octava, 17 bytes, 10 números, Agrietada

_od(3_13_13_7_1_)

Solución original

mod(3*1361357,10)
...
mod(3*1361357,17)
mod(3*1361397,17)
mod(9*1361397,17)

_ Es el personaje oculto.

Gelatina , 7 bytes , 10 números, agrietados

“1‘ỌȮḊ‘

No hay comodines.

La grieta lograda (usar una evaluación con un argumento) fue, como muchos parecen estar en este hilo, no la deseada.

El crack previsto fue:

“1‘ỌȮḊ‘ - (prints 1)
“1‘     - code page index list of characters "1": [49]
   Ọ    - cast to ordinals: ['1']
    Ȯ   - print (with no line feed) and return input: effectively prints "1"
        -     (but if left at this would then implicitly print another "1")
     Ḋ  - dequeue: []
      ‘ - increment (vectorises): []
        - implicit print: prints ""

“1‘ỌŒḊ‘ - (prints 2)
“1‘Ọ    - as above: ['1']
    ŒḊ  - depth: 1
      ‘ - increment: 2
        - implicit print: prints "2"

“1‘ỌŒḊ‘‘ - (prints 3)
“1‘ỌŒḊ‘  - as above: 2
       ‘ - increment: 3
         - implicit print: prints "3"

... keep adding an increment operator to print 4 - 10.

Befunge-93, 11 bytes, 10+ números, Agrietado

Esta presentación funciona durante al menos 1 - 10. Los caracteres no revelados se indican con □.

□□5:**-□-.@

Pruébalo en línea

Debo decir que me impresionó que dos personas pudieran encontrar soluciones independientes para esto, ninguna de las cuales era lo que esperaba. Mientras Martin llegó primero, le doy la "victoria" a Sp3000 ya que su solución es más portátil.

Sin embargo, esta fue mi solución prevista:

g45:**-2-.@
g45:**-1-.@
g45:**-1\.@
g45:**-1\+.@
g45:**-2\+.@
...
g45:**-7\+.@

Debido a que un desbordamiento de pila en Befunge se interpreta como 0, el gsolo lee de 0,0 devolviendo el valor ASCII de 'g', es decir 103. 45:**-resta 100, lo que 2-le da 3. Luego le da 1.

Para la tercera iteración, el -(sustraer ) se cambia a una \instrucción (intercambio), por lo que el 3 se convierte en la entrada más alta de la pila. Y en la iteración cuatro, +se inserta una instrucción (add), agregando así el 3 al 1 dando 4.

R, 21 bytes, 10 números agrietados

__i___________i______

Funciona para 10 números. _Es un personaje oculto.

Solución original:

which(letters%in%"a")
which(letters%in%"b")
etc.

Ruby, 16 bytes, 10 números, descifrado por xsot

x=##/=#%#
)
###x

# Es cualquier personaje.

Octava, 32 bytes, 10 números. Agrietado

_n_(isprime(floor(s____i__ i____

_ Es un personaje oculto.

Puedes probar Octave en línea aquí .

Solución original:

1: nnz(isprime(floor(sqrt(i):pi')))

2: nnz(isprime(floor('sqrt(i):pi')))

3: nnz(isprime(floor('sqrt(i):pia')))

4: nnz(isprime(floor('sqrt(i):piaa')))

...

Octava, 17 bytes, 10 números, Agrietada

_i_(__i__(2_5_))

Los caracteres no revelados están marcados con _ .

Solución prevista:

    fix(asind(2/59))
    fix(asind(3/59))
    fix(asind(4/59))
    fix(asind(5/59))
    fix(asind(6/59))
    fix(asind(7/59))
    fix(asind(8/59))
    fix(asind(9/59))
    fix(asind(9/55))
    fix(asind(9/50))

Octava, 19 bytes, 10 números, agrietados

__sca__1_)___'-_6_'

_ Es el personaje oculto.

Solución prevista:

pascal (10) ('a'-96)'

05AB1E , 5 bytes, 10 números, ¡agrietados!

No muy difícil, pero divertido :)

_[==_

_Es un personaje aleatorio. Utiliza el codificación CP-1252 . Pruébalo en línea!

05AB1E , 6 bytes, 10 números, agrietados

Intento 2, esta vez sin la cadena de tres caracteres: p.

_ [==_

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

JavaScript, 22 bytes, 10 números, agrietados

alert(0_6_4_>_0_2_0_7)

_ Es el personaje oculto.

Sugerencia sobre la solución prevista

El carácter que debe cambiarse para generar todos los números es siempre el mismo.

JavaScript 21 Bytes, 10 Números Agrietados

alert(b_oa_"3____1"))

Los caracteres no revelados están marcados con _

Agrietado

Mi version:

alert(btoa|"3"&("1"))
alert(btoa|"3"^("1"))
alert(btoa|"3"^("0"))
alert(btoa|"3"^("7"))
alert(btoa|"2"^("7"))
alert(btoa|"1"^("7"))
alert(btoa|"0"^("7"))
alert(btoa|"0"^("8"))
alert(btoa|"0"^("8"))
alert(btoa|"2"^("8"))

Python 3, 19 bytes, 10 números, agrietados

print(??bin()?????)

Los caracteres no revelados están marcados con ?. Probado en Python 3.5.2.

Python 3, 16 bytes, 10 números, agrietados

print(?%??f?r?t)

Los caracteres no revelados están marcados con ?. Esto probablemente sea un poco fácil ya que solo hay cinco signos de interrogación, pero espero que sea divertido.

C #, 90 bytes, 10 números, agrietados

using ______________________________________________;class C{static void Main(){_______;}}

Sinceramente, no tengo idea de lo difícil que es descifrarlo.

Editar: Vaya, error de transcripción. Uno _muy pocos después using.

Ahora descifrado por Hedi , quien encontró la solución deseada (salvo el nombre de la clase).

JavaScript 33 bytes, 10 números agrietados x2

Vaya, publiqué mi línea para generar 10, que Hedi rompió como si fuera 1

alert(_to__"_Xc0__0_B6____Zp=="))

Versión destinada a publicar para generar 1

alert(_to__"_Xc0__0_Bf____Zp=="))

Los caracteres no revelados están marcados con _

alert(btoa|"0Xc0"-0xBf|!("Zp=="))
alert(btoa|"0Xc0"-0xBe|!("Zp=="))
alert(btoa|"0Xc0"-0xBd|!("Zp=="))
alert(btoa|"0Xc0"-0xBc|!("Zp=="))
alert(btoa|"0Xc0"-0xBb|!("Zp=="))
alert(btoa|"0Xc0"-0xBa|!("Zp=="))
alert(btoa|"0Xc0"-0xB9|!("Zp=="))
alert(btoa|"0Xc0"-0xB8|!("Zp=="))
alert(btoa|"0Xc0"-0xB7|!("Zp=="))
alert(btoa|"0Xc0"-0xB6|!("Zp=="))

Python, 10+ números, 61 bytes, ¡Agrietado!

Aquí estaba el código que publiqué:

try:x
except:print(__import__('sys').??c??n??()[????b????e???

El código original fue:

try:x
except:print(__import__('sys').exc_info()[2].tb_lineno)

Básicamente, arroja un error ( 'x' is not defined) y luego imprime la línea en la que se encontró el error. Por lo tanto, solo sigue agregando nuevas líneas al principio para aumentar el número.

Sabía que no sería difícil de descifrar, solo quería una forma divertida de imprimir números, pero no esperaba que Sp3000 lo obtuviera tan rápido, ¡son algunas habilidades profesionales!

05AB1E, 11 bytes, ¡Agrietado!

3628801__0_

Obras de 1-10. _Es un personaje oculto.

Solución prevista:

3628801R¬0+ # 1
3628801R¬1+ # 2
3628801R¬2+ # 3
3628801R¬3+ # 4
3628801R¬4+ # 5
3628801R¬5+ # 6
3628801R¬6+ # 7
3628801R¬7+ # 8
3628801R¬8+ # 9
3628801R¬9+ # 10

Octava, 24 bytes, 9 números, agrietados

_a__repmat(__one___,__)_

_ Es un personaje oculto.

(Inspirado por el desafío de @ LuisMendo ).

JavaScript, 9 bytes, 10 números, Agrietado

alert(__)

_ Es el personaje oculto.

Octava, 25 bytes, 9 números. Agrietado

__a__repmat(__one___,__)_

_ Es un personaje oculto.