Descifre el código fuente [subproceso ladrón para intentos de descifrado]

44

Este es el hilo conductor del principal desafío Descifrar el código fuente . Si cree que ha logrado descifrar una de las respuestas de la policía, debe publicar su solución como la respuesta a este hilo.

Como recordatorio, tiene un intento de descifrar cada envío. Su intento de descifrado será una versión descifrada del código fuente. Si su conjetura coincide con la descripción (mismos caracteres, salida y, por supuesto, idioma), y usted es la primera conjetura correcta, entonces gana un punto. Es importante tener en cuenta que su programa no tiene que coincidir exactamente con el original, simplemente use los mismos caracteres y tenga la misma funcionalidad. Esto significa que podría haber más de una respuesta correcta.

El ladrón con más puntos (grietas exitosas) gana.

Tabla de clasificación

Demasiados solucionamientos

20 resuelve

15 resuelve

10 resuelve

7 resuelve

5 resuelve

4 resuelve

3 resuelve

2 resuelve

1 resolver

cops-and-robbers 
— PhiNotPi
fuente
1
Perl 5, tamaño 27, por Morot - print'pin '= ~ tr (a-za) (za-z) r
@ WumpusQ.Wumbley Todos hemos estado allí ...;)
— Martin Ender
3
Me niego a perder el tiempo intentando apaciguarlo.
Teniendo en cuenta los dos cuerpos de interrogación, parece que las respuestas revueltos / no codificados se invierten
— Mooing Pato
Ruby, 23 por MegaTom = p% ++. Métodos [80] [1 ..- 1]
— histocrat

Respuestas:

32

CJam, talla 20, por Martin Büttner

Hi "petStorm!", mame

Pruébalo en línea.

Cómo funciona

Hi                      "           int(17)                     ";
   "petStorm!",         "                    len('petStorm!')   ";
                ma      "     atan2(       ,                 )  ";
                  me    " exp(                                ) ";
                        " exp(atan2(int(17), len('petStorm!'))) ";

Descifrando el código

El resultado deseado 2.956177636986737, es un Doble o un Doble seguido de un Largo.

Usando solo los caracteres "Stop, Hammer time!", hay cuatro operadores incorporados que devuelven Dobles no enteros:

  • mS, cual es asin
  • ma, cual es atan2
  • me, cual es exp
  • mt, cual es tan

Todos ellos contienen un m, por lo que podemos utilizar como máximo tres de ellos. Solo hay uno Sy uno a.

Todos esos operadores necesitan entradas, y maes el único que consume dos entradas. Solo tenemos tres formas de impulsar Longs:

  • "...",, que empuja la longitud de la cadena (estrictamente menos de 18).
  • H, que empuja 17.
  • ...!, que empuja el NOT lógico de ....

No tenemos forma de presionar algo como falso ..., por lo que la última opción siempre presionará 0.

La salida no comienza o termina con 17o 0. Dado que 15 dígitos decimales es el número habitual de dígitos para un Doble, parecía probable que la salida fuera un Doble simple.

Suponiendo esto, el código debe caer en una de las siguientes categorías:

  • <Long> <mS|me|mt>{1,3}
  • <Long> <mS|me|mt>{x} <Long> <mS|me|mt>{y} ma <mS|me|mt>{z}.
  • Cualquiera de los anteriores, con un poco de conversión a Long ( i) o redondeo ( mo) aplicado a un Doble.

En el segundo caso, x + y + zes 1 o 2 y uno de los Long es 0 o 17.

El resto era básicamente fuerza bruta. Después de algunos intentos,

18 , {H \ ma me 2.956177636986737 =} =

regresó 9, lo que significa que

H 9 ma me

produce la salida deseada.

Todo lo que queda es eliminar todos menos 9 caracteres de la cadena. Los espacios son noops y ies un noop en Longs, por lo que "petStorm!"es una de las posibles opciones.

— Dennis
fuente
1
Eso es una locura: ¿cómo supiste cuál era el número?
— Sp3000
1
Busqué el logaritmo (y otros) de ese número pero no obtuve ningún resultado. Ahora descubrí que estaba usando una precisión demasiado alta.
— jimmy23013
2
@ Sp3000: he editado mi respuesta.
— Dennis
1
¡Muy agradable! Supongo que debería haber sacado dos caracteres más de la cadena. En mi original, en realidad tenía los espacios todavía dentro de la cadena, pero mrantes de tomar la longitud. No es que no lo hubieras descubierto también en algún momento. ;)
— Martin Ender
25

Python 3, talla 12, por xnor

()and bciprt

No hace nada (la expresión produce una tupla vacía, que no se imprime). Esto funciona debido a la evaluación de cortocircuito.

— matsjoyce
fuente
1
En Python 3 IDLE, esto genera ().
— Hosch250
@ hosch250 Dado que está en un programa (un archivo de Python), no se genera nada, ya que no existe print.
— matsjoyce
Veo. Estaba corriendo desde la línea de comandos.
— Hosch250
47
.... "thing" ....
— TheDoctor
44
@Imray Debido a cortocircuito: Python carga la tupla y comprueba si el valor de la tupla es verdadero, ya que está vacío, es falso. El código para cargar la variable bciprtnunca se ejecuta, por lo que nunca produce un NameError.
— Mateon1
20

Python, tamaño 74, por xnor

any(print(set is
set)for i in oct(chr is
map))and aeeeeeggiilnnpprrrrrstvw

Bueno eso fue divertido. Gracias a FryAmTheEggman, hosch250 e isaacg por sus sugerencias / ayuda.

— Sp3000
fuente
1
¡Buen trabajo! Mi solución fue bastante similar: list(\nprint(range is range)for aacdeeeeehmppprrrrssvwy in\noct(int is int)).
— xnor
@xnor LOL ese nombre de variable. ¿Es malo que nunca hubiera pensado en eso? : P
— FryAmTheEggman
2
@FryAmTheEggman Creo que todos esperaban que usara el truco de mi primer policía .
— xnor
@FryAmTheEggman No te preocupes, no eres el único: P
— Sp3000
13

Python 2, talla 50, de Geobits

print 2**2**2*2**2-22-2**2**2**2/2**2**2**2**2/2/2

Salidas 42.

— Ypnypn
fuente
1
Tenga un punto :) Como referencia, el original era print 2**2**2**2/2**2**2/2**2**2/2-2**2**2*2**2-22, pero no sorprende en absoluto que más de una opción sea correcta.
— Geobits
13

GolfScript, tamaño 13, de Peter Taylor

,22,{.4&?+.}/

Pruébalo aquí.

Otro, que solo descifré con gran ayuda de Sp3000. ¡Gracias!

Así que así es como llegamos allí. Sp3000 notó un montón de corridas de números consecutivos en la salida:

1,2,3,4,[2608852181],4582,4583,4584,4585,4586,[253225388392299],
142924,142925,142926,142927,142928,[302928],497409,497409

En base a eso, asumimos que esta era una secuencia creciente, que solo permitía una posible división de los números restantes:

1,2,3,4,260,885,2181,4582,4583,4584,4585,4586,25322,53883,92299,
142924,142925,142926,142927,142928,302928,497409,497409

Esos son 23 números, lo que fue un fuerte indicador para repetir el bloque 22 veces, así como para terminar el bloque con .(elemento duplicado de la pila superior), de modo que el resultado anterior quedara atrás en la pila y que la iteración final apareciera en la pila dos veces Eso es 22,{____.}/.

Ahora mirando las brechas, esos resultan ser 4tos poderes (lo cual es bueno, porque tenemos 4y ?). Más precisamente, son la cuarta potencia del índice del número actual. A continuación, observamos qué índices crearon una brecha:

4,5,6,7, 12,13,14,15, 20,21,..?

En binario esos son

00100
00101
00110
00111
01100
01101
01110
01111
10100
10101

Todos tienen el tercer conjunto de bits, lo que significa que el índice probablemente sea solo bit a bit y 'con' 4(lo cual es bueno nuevamente, porque podemos hacer otro 4con .y tener a &). Esto funciona particularmente bien, porque esta operación da como resultado 0o 4, y si lo usamos como exponente, obtenemos una 1o una cuarta potencia, que es exactamente lo que necesitamos. Así que vamos a poner eso juntos:

22,{.4&?+.}/

Esto es lo que hace el bloque:

.      # Duplicate current index
 4     # Push a 4
  &    # Bitwise and
   ?   # Raise index to resulting power
    +  # Add to previous result
     . # Duplicate for use in next iteration

Ahora quedaban dos problemas: teníamos un parásito ,que aún no usábamos, y la primera iteración es un caso especial, en el sentido de que no hay ningún valor de una iteración anterior a la que podamos agregar cosas cuando nos encontremos +. Descubrimos que gracias a un comentario no relacionado del usuario 23013 que mencionó casualmente que GolfScript comienza con una cadena vacía en la pila (si no hay nada en STDIN). Así que podríamos usar ese otro ,derecho al principio para convertir esa cadena en un 0, que era justo lo que necesitábamos al comienzo de la iteración.

— Martin Ender
fuente
Correcto. Esto se inspiró en una secuencia en OEIS que no puedo encontrar ahora.
— Peter Taylor
3
Y es por eso que tener un hilo separado para los ladrones es una buena idea. ¡Buen trabajo!
— Dennis
11

Ruby, talla 17, por Pomo

p 2,%r~n~i=~'*tN'

Eso fue muy divertido. ¡Gracias a Sp3000 por ayudarme con esto! Y aprendí que los %r?...?literales pueden tener delimitadores. :)

— Martin Ender
fuente
10
Apoyos para Doorknob por ser increíblemente engañoso print, solo para dividirlo ppara imprimir, %rpara expresiones regulares y ipara la coincidencia de expresiones regulares sin distinción entre mayúsculas y minúsculas.
— Sp3000
11

PHP, tamaño 49, por bwoebi

print@substr(new exception,+~$$a+=++$$m+$$i+2+n);

Eso fue absolutamente mental .

Llegó a

print@substr(new exception,);

bastante rápido, momento en el que necesitaba algo que da -6después de la coma, después de haberme $++$++$++$+=$~main$2ido.

El problema principal es que $a, $my $ison todos NULL, por lo que usarlos indirectamente en variables variables significa que todos apuntan a la misma variable. Sin embargo, PHP parece estar haciendo algunas cosas raras al resolver variables variables. Con variables normales puedes hacer cosas como

echo $a+$a=2;

que imprime 4( 2se asigna $ay luego se agrega a sí mismo). Pero si hago lo mismo con variables variables:

echo $$a+$$a=2;

Lo entiendo 2, porque ahora el primero $$aes evaluar antes de la tarea.

Al final, logré forzar un poco de orden poniendo algunos incrementos en el RHS de los +=que tuvieron que ser evaluados antes de esa asignación adicional. De esa manera llegué a 5lo que podría simplemente complementar. Aún así ... están sucediendo algunas cosas misteriosas, y no tengo idea de por qué la mitad de las cosas que probé funcionaron y no funcionaron.

— Martin Ender
fuente
Como referencia, mi original:print@substr(new exception,~$$mn+=2+$$a+++$$i++);
— bwoebi
Por cierto. Espero que todos los signos de dólar y el hecho de que todas las letras mainestén en la cadena te engañen mucho. Además, {main}creo que es un método bastante inusual para extraer ;-)
— bwoebi
@bwoebi The mainrealmente no me engañó , después de verlo exception, newy substr. Pensé que solo serían nombres de variables. Me tomó un tiempo encontrar variables variables y dediqué la mayor parte del tiempo a calcular algún orden de operaciones que realmente produjera un 5que podría complementar sin usar otro conjunto de paréntesis.
— Martin Ender
Bueno, para la próxima vez, si hay más dólares que caracteres, generalmente son variables variables. (En este caso, también abusé de los varvars para forzar la evaluación de izquierda a derecha). ¿Cuánto tiempo tardó en detectar la nueva excepción substr? También, por cierto, tengo un conocimiento más profundo del motor Zend, así que puedo explicarme perfectamente por qué las cosas se evalúan en qué orden y eso es bueno para estos desafíos ;-) Si hay algo específico que no entiendes, yo ' felizmente te lo explicaré.
— bwoebi el
@bwoebi Entra en el chat mañana, y podemos hablar de eso, pero hoy he pasado bastante tiempo en esto. ;) En cuanto a su primera pregunta, exceptionera obvio, lo que dejaba a los personajes callejeros substry newpor ahí. Fue literalmente lo primero que vi cuando comencé a trabajar en ello.
— Martin Ender
9

Ruby, talla 38, por Pomo

[$><<(!$pece60).to_s[rand($win)].succ]

Estoy bastante seguro de que esto no está cerca de la fuente original. Es determinista a pesar de usar rand.

Así es como funciona este. $><<Es solo salida. $pece60y $winson variables globales indefinidas, que por lo tanto son justas nil(y me permitieron deshacerme de algunos caracteres extraños). !$pece60hace un truey to_sle da la cuerda "true".

Durante años, intenté obtener un 2o -2acceder a eso uallí, pero luego me di cuenta de que podía tomar el ty llamar .succ(essor) para hacer un u.

randcon un nilparámetro devuelve un flotante aleatorio en el intervalo [0,1). Cuando se usan flotantes para indexar en cadenas, se truncan en enteros, por lo que esto siempre devolverá el primer carácter.

Finalmente, tenía un par adicional, []así que simplemente envolví todo en él, porque afortunadamente todo es una expresión en Ruby.

Gracias a Sp3000 por lanzar algunas ideas en el chat.

— Martin Ender
fuente
8
Ruby es un lenguaje de aspecto aterrador.
— Feersum
8

C, 51 por es1024

c=0xf.cp9,hhtaglfor;main() {;; printf("%d",(++c));}

Después de 20 años de programación C hoy, aprendí sobre las constantes hexadecimales de coma flotante.

— Arte
fuente
8

Ruby, 45 (histocrat)

%q[zyfnhvjkwudebgmaclprs x].to_i(36)/51074892

Woohoo! Esta es mi primera grieta en un problema de código de golf, y no tengo suficiente representante para comentar sobre la publicación original. Inmediatamente reconocí el truco utilizado, ya que en realidad lo he encontrado en el código de producción a menudo. Tardó unos 5 minutos en descubrir la mayor parte de la estructura y unas pocas horas en encontrar la respuesta completa.

Explicación:

  • %q[]es un método alternativo para crear cadenas. También se pueden usar paréntesis y llaves.
  • String#to_i en Ruby acepta números en cualquier base del 2 al 36. Ignorará el primer carácter de la cadena que no es parte del número, por lo que cualquier carácter adicional puede "desecharse" después del espacio.

Y aquí está el código que usé para descifrarlo:

require 'set'

# return true if the string is made up of unique characters
def uniq(s)
  a = s.each_char.to_a
  return a == a.uniq
end

def uniq_while_same(a,b)
  s = Set.new
  a.each_char.zip(b.each_char).each do |ai, bi|
    return true if ai != bi
    return false if s.include? ai
    s << ai
  end
  return true
end

def ungolf(answer)
  # For each base that even makes sense
  [            36, 35, 34,     32, 31, 30,
   29, 28, 27, 26, 25, 24, 23,     21, 20,
   19, 18, 17, 16, 15, 14, 13, 12,     10].each do |base|
    # Ignore bases where it is not possible to create a unique-string number greater than answer
    next if answer > base ** base
    # Pick digits for the denominator that are not duplicates of the digits in base
    denominator_digits = ('1234567890'.each_char.to_a - base.to_s.each_char.to_a)
    # For each permutation of those digits for the denominator
    (1..10).each do |denominator_length|
      denominator_digits.permutation(denominator_length) do |denominator_s|
        # Maybe the denominator is in octal
        denominator_base = 10
        if denominator_s[0] == '0'
          next if denominator_s.include?('8') || denominator_s.include?('9')
          denominator_base = 8
        end
        denominator_s = denominator_s.join
        denominator = denominator_s.to_i denominator_base
        print "#{"\b"*64}(%q[#{(answer * denominator).to_s(base).ljust(36)}].to_i #{base})/#{denominator_s.ljust(10)}" if rand < 0.01
        # Ignore denominators that are definitely impossible to have answers for
        next unless uniq_while_same "qtoi#{base}#{denominator_s}#{(answer * denominator).to_s(base)}",
                                    "qtoi#{base}#{denominator_s}#{((answer + 1) * denominator).to_s(base)}"

        # For each numerator that gives answer when divided by the denominator
        (answer * denominator...(answer + 1) * denominator).each do |numerator|
          print "#{"\b"*64}%q[#{numerator.to_s(base).ljust(36)}].to_i(#{base})/#{denominator_s.ljust(10)}" if rand < 0.01
          # Remove any that are still not unique
          s = "#{numerator.to_s(base)}#{base}#{denominator_s}qtoi"
          next unless uniq s
          # Done. Compute which characters need to be thrown away to fill the remaining space
          remains = ('0123456789abcdefghijklmnopqrstuvwxyz'.each_char.to_a - s.each_char.to_a).join
          print "#{"\b"*64}#{" "*64}#{"\b"*64}"
          return "%q[#{numerator.to_s(base)} #{remains}].to_i(#{base})/#{denominator_s}"
        end
      end
    end
  end
  print "#{"\b"*64}"
  puts "\nnone"
  return nil
end


print ungolf 9410663329978946297999932

Manera de ir incrustando un problema NP dentro de un acertijo. He sido completamente francotirador. ¡Buen trabajo!

— utensilio carbonizado
fuente
Agregué un comentario a la respuesta original para ti.
— FireFly
Esto es impresionante (y cercano a la respuesta prevista), pero técnicamente no es válido porque no tiene salida.
— histocrat
* Facepalm Bueno, todavía me divertí.
— charredUtensil
2
@charredUtensil si no te importa ejecutar tu script por más tiempo, creo que la impresión solo está moviendo pa antes de la expresión. Presumiblemente, los caracteres restantes se pueden usar para formar las constantes como lo has hecho.
— FireFly
En realidad no necesito ejecutarlo de nuevo. Los últimos caracteres de la cadena se pueden reordenar sin cambiar el resultado - p %q[zyfnhvjkwudebgmaclrsx].to_i(36)/51074892Sé que me rompí el intento de craqueo real aunque :)
— charredUtensil
7

CJam, tamaño 13, por user23013

G,Cf#If/sE*K%

Pruébalo aquí.

Resuelto a mano, así:

Primero, algunos antecedentes para quienes no son CJammers:

  • CEGIKson todas las variables, que son pre-inicializado a 12, 14, 16, 18, 20, respectivamente.
  • s convierte el elemento de la pila superior en una cadena.
  • Las cadenas son técnicamente solo matrices de caracteres.
  • fEs bastante mágico. Para el propósito de esta respuesta, la versión simplificada es que, para una matriz a, algún otro valor by un operador g, la secuencia de abfgmapas g(_,b)a a(donde cada elemento de aentra en la _ranura).
  • / son matrices de división y división (entre otras cosas).
  • * es la multiplicación y la repetición de matrices (entre otras cosas).
  • %es un módulo y una operación extraña, que en la forma ad%de matriz ae entero dtoma cada delemento de a(como el corte de Python con ancho de paso d).
  • # es exponenciación (entre otras cosas).
  • ,convierte los números en rangos (de 0a n-1) y devuelve la longitud de una matriz.

De acuerdo, eso fuera del camino ...

Era bastante obvio que necesitábamos ,convertir un número en un rango, porque la única otra forma de obtener una matriz habría sido construir un número mayor y convertirlo en una matriz de caracteres con s, pero no podríamos haber hecho nada más aritmética en él. Y necesitamos una matriz para hacer algo con el fs.

Primero supuse que los fs se usaban con #y %, pero eso significaría que habríamos necesitado un número alrededor de 90 para obtener la cantidad correcta de dígitos al final. Y además, esto no explica qué hacer con eso s, y dado que la respuesta parecía realmente interesante, dudé que user23013 simplemente agregara un scomo un no-op eficaz en algún lugar para desanimar a la gente.

Así que pensé, tal vez él ni siquiera está manteniendo los números pequeños %, sino que construye una serie de números enormes, concatena su representación de cadena con s, pero luego solo selecciona un corte extraño %. Así que jugué un poco con el siguiente marco:

__*,_f#_f/s_%

(No puede hacer _f/primero, porque eso produciría cero para al menos los primeros 12 elementos).

Donde _hay alguna permutación de las variables. No los probé todos antes de aburrirme, y el principal problema con esto fue que la secuencia resultante de dígitos siempre es demasiado larga.

En algún momento se me ocurrió, que no necesitaríamos un rango tan grande (es decir, el producto de dos números), si en su lugar utilizamos el *para repetir la cadena resultante. Debido a la falta de coincidencia de los parámetros de *y %esto no produciría repetición en el resultado:

_,_f#_f/s_*_%

Esto arrojó resultados de una longitud muy cercana a lo que estaba buscando. Hubiera intentado los 240, pero bastante rápido (tercer o cuarto intento), me topé con

E,Cf#If/sG*K%

cuyos rendimientos

03081942753650251594592190492275006661328850322159030034930530649722385533653290754678977

Y supuse que una coincidencia de los primeros seis dígitos no sería una coincidencia. Entonces, la pregunta era cómo reorganizarlo sin alterar el cálculo real:

  • No pude cambiar Kporque eso seleccionaría diferentes dígitos por completo.
  • No pude cambiar Co Iporque eso cambiaría los números resultantes de las dos operaciones del mapa.
  • Si cambiara Geso solo cambiaría el número de repeticiones, lo que no haría nada más que cambiar la duración del resultado. (Lo que es bueno.)
  • Si cambiara Eeso, cambiaría el rango de la matriz, pero el rango aún comenzaría [0 1 2 3 ...], por lo que no afectaría el cálculo. Se podría afectar a la longitud de la cadena devuelta por la base s, que también significaría que K%habría seleccionar diferentes dígitos en repeticiones adicionales.

Intercambiando así que sólo probé Ey Gy listo:

030819828850379075460427536222159187897761502517030034671154875945928930530907551421904962649729

En resumen, esto es lo que hace el código:

G,            "Push [0 1 2 3 ... 13 14 15].";
  Cf#         "Raise each element to the 12th power.";
     If/      "Divide each element by 18.";
        s     "Concatenate all numbers into a string.";
         E*   "Repeat 14 times.";
           K% "Pick every 20th digit.";
— Martin Ender
fuente
6

Pyth, talla 11, por isaacg

:\\w$ ",d,N

Eso es un mal abuso de errores allí mismo. Esto compila a:

Pprint("\n",at_slice("\",input(), ",d,N))

El error relevante es que \\compila en "\"lugar de "\\", lo que le permite compilar Pyth en una cadena.

— Martin Ender
fuente
¿Debería Pprintser print, o al menos pprint?
— FireFly
@FireFly Eso es lo que dice la salida de depuración. ¿Quizás el intérprete de Pyth define su propio Pprint?
— Martin Ender
Oh, está bien, no importa entonces.
— FireFly
6

Python, tamaño 69, por Sp3000

print(sum(list(map(ord,str((dict(((str(dict()),list()),)),str()))))))

Eso fue difícil...

— grc
fuente
1
¡Agradable! Como referencia, el original era print(sum(map(ord,str((dict(list(((str(),str(dict())),))),list()))))), pero obviamente funcionarían muchas permutaciones diferentes de palabras clave.
— Sp3000
2
¡Ese es un nivel LISP de padres allí!
— xnor
6

Python 3, 37 bytes, por Sp3000

print(sum(b"a".zfill(len(str(...)))))

De manera vergonzosa, la parte más difícil fue encontrar la cadena en bytes. Tuve que dormir en él, y en la noche me di cuenta '¡duh, es un literal de bytes!'

— Blake Walsh
fuente
Jajaja, bien hecho, pensé que los puntos suspensivos podrían hacer tropezar a la gente, pero supongo que no
— Sp3000
Vi los puntos suspensivos y zfill, pero no sabía acerca de los objetos de bytes. ¡Esos podrían ser útiles en juegos de golf de enteros!
— Feersum
¡Gran trabajo! Solo vi la impresión y el .zfill, y sabía que la suma podría ser parte de ella, pero no pude resolverlo. Tener un +1.
— Hosch250
6

PHP, 53, por favor

Lo descifré por fin:

for($d=57,$o=35;$o+$d<999;)$o+=printf("$d%o",$d+=$o);

La solución llegó bastante rápido cuando noté que la secuencia consiste en alternar números decimales y octales:

Dec: 57...92...132...177...228...285...348...417...492....573....661....756....858....
     571349220413226117734422843528553434864141775449210755731225661136475615328581707
Oct: ..134..204...261...344...435...534...641...754...1075...1225...1364...1532...1707
==Dec:  92  132   177   228   285   348   417   492    573    661    756    858    967

Además, los intervalos entre cada conjunto de números crecieron a una velocidad igual al valor devuelto por printf()(es decir, el número de caracteres escritos).

— ossifrage aprensivo
fuente
3
Wow, buen trabajo de detective!
— Sp3000
6

Python 2, tamaño 132, de Vi.

exec('from string import printable as e\nprint "cqance"\x2Ereplace("q",e[len("fgiillmmooprrsstt")])or ",,,\016:::S[]____tuuvyy" ""')

Gracias por todas las barras invertidas y comillas :)

Editar: La versión actualizada de 96 caracteres:

exec "try:exec'from __future__ import braces\\nt(12)'\nexcept SyntaxError as q:print(q[0][6:])"

Esto está tomado completamente de la solución de Alex en https://codegolf.stackexchange.com/a/41451/32353

— kennytm
fuente
Je, bien. Preguntándome cuál era la solución indended ...
— FireFly
Esta no es una solución prevista. La solución original no tiene elementos "desechables" como fgiillmmooprrsstto ,,,\016:::S[]____tuuvyy.
— Vi.
exec? Mi código podría haber sido más corto ... Lo estaba emulando con compile+ evalporque me olvidé de exec...
— Vi.
Implementado la versión más corta. Intenta descubrir el truco original.
— Vi.
5

CJam, talla 15, por Ypnypn

98,{7%}%{6+}%:+

De los caracteres dados, supuse que tenía que ser una de las tres formas siguientes:

__,{_%}%{_+}%:+
_,{_%}%{__+}%:+
__,{_+}%{_%}%:+

que crea un rango de dos dígitos, luego asigna una operación de suma y módulo (en cualquier orden) en el rango, antes de sumarlo. Así que comencé con el primero y probé sistemáticamente las permutaciones 6789en los huecos.

— Martin Ender
fuente
Maldición, también lo resolví: /
— Optimizer
5

Python 2, tamaño 61, por FryAmTheEggman

print(dir('~s]l.c:st_''-p_tp.l]-~.:o:Te[_u[.i_')[10][2:][:3])

Me sorprendería mucho si esto coincide con el original.

— grc
fuente
No lo hace, pero felicidades de todos modos! Mi código fue:print''.__doc__[::2][::3].split()[1].split('.')[0][:-~-~True]
— FryAmTheEggman
En retrospectiva, no debería haber incluido las citas ...;)
— FryAmTheEggman
@FryAmTheEggman Oh wow - ¡buen programa! Estaba convencido de que al menos solías dir()encontrar el 'get'. Y sí, hubiera sido muy difícil sin las comillas.
— grc
5

Python 3, Sp3000, talla 44

print(~(~(()<((),))<<(()<((),))))<<((()<()))

Python 3 me ayudó aquí, ya que pude causar un error (desplazamiento a la izquierda Nonepor algo) después de imprimir la respuesta.

— Feersum
fuente
Hmm ... parece que fui bastante despilfarrador con mis padres Tenía print(~(~(()<())<<((()<((),))<<(()<((),)))))originalmente.
— Sp3000
5

PHP, tamaño 52, por kenorb

_:@print_r(chr(@++$i+pow(3<<5,1)));if($i<2*4)goto _;

(Dios, cuánto tiempo me llevó pensar qué hacer con el _rsufijo restante . Hasta que me di cuenta de que no era así print, pero print_r...)

— bwoebi
fuente
Y no sé cómo te diste cuenta :) Original: _:print_r(chr(3*pow(2,5)+@++$i));if(@$i<4<<1)goto _;.
— kenorb
3
@kenorb a) necesita imprimir algo, por lo que echono es posible; printse mantuvo; b) necesitas algo de bucle, pero para un forbucle, no había suficientes puntos y comas, y bueno, hay dos puntos ... así que probablemente haya una etiqueta allí en combinación con goto; c) entonces necesita un if para abortar el goto-loop. Tener ahora X:print($Y);if($Y)goto X;(X e Y son marcadores de posición); d) hay un ++, pero no =, así que probablemente algunos ++$Zdel 1 al 8; e) para obtener letras de un número entero, necesitamos chr()(generalmente): estaba allí; f) ahora solo necesitaba encontrar los números 96 y 8 para chr y if. Luego complete los marcadores de posición y volià.
— bwoebi
5

C, es1024, longitud 70

e='C',f;main(g){Chorkil:f=printf("40%.d",e+e-  -g);}hAx;*hotpoCkats();

La parte difícil fue hacer un seguimiento de todos los personajes innecesarios ... en serio ... tuve que rehacerlos unas 10 veces. ¡El único que me preocupó fue el, .pero de alguna manera lo pegué en el medio de la printfcadena de formato y se volvió invisible!

— Feersum
fuente
5

Haskell, talla 34, de Petr Pudlák

main=print(0xb2f3d5^0x7f1f27::Int)

Tenga en cuenta que este programa debe ejecutarse en una máquina de 32 bits. Si desea verificar que este es el programa correcto y tiene una máquina de 64 bits, puede usar esto en su lugar:

import Data.Int
main=print(0xb2f3d5^0x7f1f27::Int32)

Fue bastante fácil adivinar el "marco" del programa main=print(0x<hex digits>^0x<hex digits>::Int). Toda la magia estaba en buscar la forma correcta de particionar y ordenar los dígitos. No hice mucha inteligencia aquí, solo una búsqueda de fuerza bruta ... aunque sí me aseguré de abusar del hecho de que algunos dígitos estaban duplicados, probablemente había aproximadamente un número igual de dígitos en la base y el exponente, y el último dígito de la base casi seguro no era par. El código de búsqueda completo se incluye a continuación; Utiliza el paquete multiset-comb . La búsqueda completa dura aproximadamente 10:33 en mi máquina (y produce una sola respuesta correcta, por supuesto).

{-# LANGUAGE NoMonomorphismRestriction #-}
import Control.Monad
import Data.Int
import Data.List (inits, tails, group)
import Numeric
import Math.Combinatorics.Multiset

main = print (searchFor (-1121766947))

searchFor n = do
    nl <- [6,5,7,4,8,3,9,2,10,1,11]
    (l_, r_)  <- chooseSubbag nl digits
    l <- perms l_
    guard (last l /= '2')
    r <- perms r_
    guard ((fromString l :: Int32) ^ (fromString r :: Integer) == n)
    return (l, r)

chooseSubbag n = chooseSubbag' n . group
chooseSubbag' n xss = go (drop (n-1) (concat xss)) n xss where
    go _  n xss | n < 0 = []
    go _  0 xss = [([],concat xss)]
    go [] n xss = []
    go m  n (xs:xss) = do
        (kx, tx) <- zip (tails xs) (inits xs)
        (k , t ) <- go (drop (length tx) m) (n-length kx) xss
        return (kx++k, tx++t)

digits = "1223577bdfff"
fromString = fst . head . readHex
perms = permutations . fromList
— Daniel Wagner
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.