Espacio en blanco significativo: policías

51

Para el propósito de este desafío, definiremos los espacios en blanco como solo saltos de línea (0x0A) y espacios (0x20). Tenga en cuenta que la mayoría de los idiomas y los sabores de expresiones regulares también consideran muchos otros caracteres como espacios en blanco, tanto dentro como fuera del rango ASCII, por lo que es posible que no pueda utilizar los elementos integrados correspondientes.

El desafío de los policías

Debe escribir un programa o función en el idioma que elija, que toma una cadena, que consta de caracteres ASCII (excepto NUL), como entrada y salida con todo el espacio en blanco eliminado. Por ejemplo, si recibió la siguiente entrada:

H e l l o,
 W o r l  d!

Usted debe salir

Hello,World!

Su envío será entonces su código fuente con todo el espacio en blanco eliminado (el mismo proceso que pasar su solución como entrada para sí mismo, aunque su solución también puede contener caracteres fuera del rango ASCII). Su objetivo es hacer que sea lo más difícil posible averiguar dónde se debe insertar un espacio en blanco para recuperar una solución válida en el idioma que elija. Tenga en cuenta que los ladrones pueden insertar menos espacios en blanco de los que eliminó, pero no más. Recuerde también que los ladrones no tienen que coincidir con su código exacto, solo tienen que encontrar una solución válida.

Su respuesta debe contener lo siguiente:

  • El idioma (y la versión si es necesario) en el que escribió su solución.
  • El recuento de bytes de su solución antes de eliminar espacios en blanco.
  • Su solución con espacios en blanco eliminados.

Su solución puede ser un programa o una función, pero no un fragmento y no debe asumir un entorno REPL. Puede tomar la entrada a través de STDIN, argumento de línea de comando o argumento de función y salida a través de STDOUT, valor de retorno de función o parámetro de función (out).

En aras de la equidad, debe haber un intérprete o compilador disponible gratuitamente para el idioma elegido.

No debe utilizar las funciones integradas para el hash, el cifrado o la generación de números aleatorios (incluso si coloca el generador de números aleatorios en un valor fijo). Su solución debe poder procesar cualquier cadena de 100 caracteres o menos en menos de 10 segundos en una máquina de escritorio razonable.

Si su respuesta no ha sido descifrada dentro de los 7 días (168 horas), puede revelar su propia solución, momento en el cual su respuesta se considera segura . Siempre y cuando no reveles tu solución, los ladrones todavía pueden descifrarla, incluso si ya han pasado los 7 días. La respuesta segura más corta gana (medida antes de eliminar espacios en blanco).

Si su respuesta se agrieta, indíquelo en el encabezado de su respuesta, junto con un enlace a la respuesta del ladrón correspondiente.

Ve aquí por la parte de los ladrones.

Envíos sin descifrar

<script>site = 'meta.codegolf'; postID = 5686; isAnswer = false; QUESTION_ID = 103182;</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>

Martin Ender
fuente
Relacionado. (Inspiración, de hecho.)
Martin Ender
77
Parece que los espacios en blanco se rompería este desafío ...
NoOneIsHere
8
@SeeOneRhino ¿Por qué? El ladrón solo tiene que resolver el problema en el espacio en blanco, sin usar más bytes que el policía. A menos que un policía encuentre una respuesta de Whitespace locamente bien desarrollada que nadie pueda igualar, las respuestas de Whitespace son generalmente las más vulnerables en este desafío.
Martin Ender
1
@SeeOneRhino Además, las pestañas no cuentan como espacios en blanco, por lo que no se eliminarán.
mbomb007
44
Esta vez no habrá presentaciones de hexagonía, supongo
MildlyMilquetoast

Respuestas:

17

Haskell, 100 bytes, descifrado por nimi

main=interact$iddoidlinesidwordsdoidoidoid=doiddoid<-dooiidoid<-dooiddoiddodoid

Este es un programa completo y un poema dadaísta.


Código con withspace (¡Pruébelo en línea!)

main=interact$id doid lines id words
doid oi d o id=do
 iddoid<-do oi id
 oid<-do o iddoid
 do d oid

Sigue pareciendo bastante poético, si me preguntas.

Desfuscado

main = interact f
f s = do
 l <- lines s
 w <- words l
 id w

Explicación

La donotación es solo azúcar sintáctico, por lo que fse puede escribir

f s = lines s >>= words >>= id

Para las listas, el >>=operador se define como concatMap, por lo que se fconvierte en

f = concat . map id . concat . map words . lines

Entonces, dada una entrada "a b\nc", linesdivide la entrada en nuevas líneas ["a b","c"], wordsdivide cada línea en el espacio en blanco cediendo [["a","b"],["c"]](como me di cuenta solo ahora que esto incluye nuevas líneas, por lo que en linesrealidad no es necesario). Concatenar una vez da ["a","b","c"], ides la función de identidad y, como tal, no tiene ningún efecto y la concatenación final produce la cadena "abc".

Laikoni
fuente
3
¿Debo decir que me gustan los poemas dada istic?
Dada
@nimi sí, bien hecho.
Laikoni
12

C, 475 bytes, descifrado por Riley

Ciertas partes de C hacen que sea realmente fácil ver hacia dónde debe ir el espacio en blanco. El preprocesador c, sin embargo, no. Entonces, este código se divide en dos mitades: hasta la línea 17 (236 caracteres con espacios en blanco), el código está prácticamente sin ofuscar, y después de eso (239 caracteres con espacios en blanco), ¡buena suerte!

No voy a ganar esta competencia ni mucho menos, pero quería ver qué se podía hacer con el preprocesador c.

#include<unistd.h>#defineachar#defineb*#definecwrite#definedstdin#defineestdout#definefread#defineg(#defineh)#defineiwhile#definejif#definek0#definel&#definem,#definen=#defineo;#definep1#definegpmlmlh#defineabo#definemldmp#definejgdoabo#definelbabod#definegfhaboc#definejgmben#definepmlfg#definegpmlbintmain(){ajgajgmljgigpmlkmlgpmlhjgd!=''&&gpm!='\n'gfgpmlgpmlo}

Compila (con advertencias, si las habilita) con gcc -std=c89 -ansiy funciona comocat file | ./a.out


Esto fue resuelto mucho más rápido de lo que pensaba, ¡felicidades! Mi estrategia consistía en utilizar #definespara eliminar límites de token obvios (como ';') y luego usar más #definespara que REALMENTE no fuera intuitivo cómo se barajaban.

Esto, por cierto, es el aspecto del código después de que solo se haya agregado el espacio en blanco obvio:

#include <unistd.h>
#define a char
#define b *
#define c write
#define d stdin
#define e stdout
#define f read
#define g (
#define h )
#define i while
#define j if
#define k 0
#define l &
#define m ,
#define n =
#define o ;
#define p 1
// thus begins the obfuscation
#define gpmlmlh
#define abo
#define mldmp
#define jgdoabo
#define lbabod
#define gfhaboc
#define jgmben
#define pmlfg
#define gpmlb
int main(){
    ajgajgmljgigpmlkmlgpmlhjgd!=''&&gpm!='\n'gfgpmlgpmlo
}
rexroni
fuente
55
Bienvenido a PPCG! :)
Martin Ender
1
Agrietado Esta manera realmente divertida.
Riley
9

Octava, 69 bytes, ¡SEGURO!

@(U)eval([85329685312682956148388531268295156241''])

Formato de entrada: no se pueden ingresar líneas nuevas directamente en el símbolo del sistema. Cree la cadena por concatenación de esta manera:

str = ['This is ',10,'a',10,'string']
str = This is
a
string

Llame a la función de esta manera (agregue espacios en blanco):

f=@(U)eval([85329685312682956148388531268295156241''])  
f(['This is ',10,'a',10,'string'])

Código original:

Solo necesitabas 66 bytes para que esto funcionara, pero escribí 69 en el encabezado para no dar demasiada información.

El código original se ve así:

@(U)eval([853 296 853 126 829 561 48 38 853 126 829 51 562 41 ''])

Explicación:

@(U)eval(.....)    % Anonymous function taking U as the input variable

Ues el punto de código 85en la tabla ASCII, por lo que parecería que el primer espacio debería estar después 85. ¡Incorrecto!

Si en su lugar insertamos el espacio después 853, deberíamos obtener el número de carácter 853, ¿verdad ...? Utilizando charpara verificar si ese es un personaje reconocible:

char(853)
warning: range error for conversion to character value

Sin embargo, no usamos charen el código, usamos la versión más corta donde concatenamos los números con una cadena vacía [853 '']. En lugar de dar un error fuera de rango, la versión más corta simplemente toma el módulo de números 256.

Da la casualidad de que es eso 85+3*256 = 853. Mientras char(853)da una advertencia, [853,'']vuelve U.

La forma obvia de hacer esta tarea en Octave es:

@(U)U(U~=10&U~=32)

Sabemos que debe haber un paréntesis de apertura (punto de código 40) después del primero U. 29obviamente no encaja, así que desplazamos el espacio uno más a la derecha y obtenemos 296. mod(296,256) = 40. ¡Bingo!

Continúa así y termina con la secuencia:

[853 296 853 126 829 561 48 38 853 126 829 51 562 41 '']
ans = U(U~=10&U~=32)

Finalmente, usamos evalpara convertir la cadena en código.

Stewie Griffin
fuente
3
+1 por explicar el formato de entrada en 2 líneas mientras me tomó 10 :-D
Luis Mendo
1
Bueno, todavía no tengo idea, excepto que ahora reconozco la letra Uentre ese grupo de números :-)
Luis Mendo
2
Muy buen truco! Es una locura que Octave lo haga con códigos de personajes. No tenía idea al respecto. Pero entonces, ¿qué puede esperar cuando el documento oficial dice que Octave apoya a Unicode por accidente ... :-P
Luis Mendo
7

JavaScript ES6, 199 bytes, descifrado por SLuck49

Una entrada bastante voluminosa con 33 bytes de espacio en blanco para agregar.

s=>eval(atob`ISYgJiAtOkI8Qk97BRBeaxZFShoUZSsiOGkMenNy`.replace(/./g,(c,i)=>String.fromCharCode(c.charCodeAt()^(k+="SecretCode".split(/\w/)[i%11].length)),k=0)).join``
Arnauld
fuente
Bonito ... Supongo que necesitamos agregar la cantidad adecuada de espacios en blanco a "SecretCode" para poder xor la cadena encriptada y obtener la fuente adecuada ~
Patrick Roberts
@PatrickRoberts Sí, exactamente.
Arnauld
Ya tengo un script automatizado que prueba todas las combinaciones posibles, es solo cuestión de tiempo ... junta las manos, sabiendo que su malvado plan está funcionando
Patrick Roberts
Uf ... esto está tomando más tiempo de lo que pensaba. Estoy pensando en escribir un código de desafío de golf para calcular el número de permutaciones posibles, dada una matriz de longitud N y una suma S que los elementos deben sumar. En este momento estoy en [ 10, 0, 0, 0, 0, 9, 8, 1, 5, 0, 0 ]la secuencia gap y mi función de iteración para la matriz es (a)=>{for(var x=0;!a[x];x++);if(a.length-x>1){a[0]=a[x]-1;a[x]=(x==0?a[x]:0);a[x+1]++;}else{a[0]=a[x]+1;a[x]=0;i=0}}. Empecé a [ 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ].
Patrick Roberts
6

> <>, 40 bytes, Agrietado por Teal pelican

v<<i/\:=::a?0/>/1?o-=="?;">^

Por cierto, utilicé fishlanguage.com , en caso de que haya diferencias entre los intérpretes.

DanTheMan
fuente
3
Cracked
Teal pelican
6

Befunge-93, 58 bytes, ¡seguro!

_vv$v<~:!`:<#^0*@-:0*5|845\+`-v0,<#-^<

Pruébalo en línea!

Programa original

_vv
 $ v<
 ~:!`
 :<#^0
*  @
-:0
*5 |
8
45
\+`
-
v0,<
#-
^<

Pruébalo en línea!

El truco para esto fue que la ruta de ejecución era más vertical que horizontal, luego se insertaron varios espacios al azar en el código para barajar aún más las rutas verticales. Una vez que los saltos de línea y los espacios en blanco finalmente se eliminaron, es de esperar que haya muy poco para indicar cómo se relacionan las operaciones entre sí.

En caso de que no fuera lo suficientemente difícil, también agregué un poco de intercalación, por lo que varias operaciones terminaron siendo ejecutadas por diferentes rutas de código que fluyen perpendiculares entre sí. La idea es que si crees que has encontrado la posición correcta para un comando en particular, no te darás cuenta de que es posible que tengas que volver a usarlo más adelante en el código.

No estoy seguro de si valió la pena todo ese esfuerzo tratando de complicar las cosas, o si la gente ni siquiera se molestó en tratar de resolverlo. :)

Explicación del código

_      Since an empty stack is treated as zero, this initially just branches right.
v      The program flow is then directed downwards.
$      And this drop command initially does nothing because the stack is still empty.
~      A character is read from stdin.
::     Two duplicates are created.
55+-   We subtract 10 from the first copy (the 0- is just a nop to confuse things).
\48*-  And subtract 32 from the second copy.
*      The product of those two will be zero if the character is a newline or space.
_      So if we got whitespace, our branch goes right again repeating the loop.

v      If not, we go left, wrapping around till we hit the down arrow in column 3.
:<:    Again we make two duplicates of the character.
0`!|   One copy is used to compare if it's not greater than zero.
@      If it's not (i.e. it's the EOF), the branch goes up and we terminate.
<      Otherwise we go down and to the left.
,      Output the second copy of the character, leaving one remaining on the stack.
0      Push a zero to force the next branch right.
v      Redirect the flow down, wrapping to the top again.
_      Back at our initial branch, the zero we pushed forces us right.
v      Again the program flow is directed downwards.
$      And the drop command gets rid of the last duplicate character.
~      So now we're back reading the next character and the loop repeats.
James Holderness
fuente
5

C # 6, 201 bytes, Agrietado por enlace Ng

usingSystem.Linq;_=>string./**/#iftrueJoin(/*"*//*/""/**//*/"*/",#elseConcat(//*/,#endiffrommin""letp=$@"{@""[1]}"fromiin(_.Replace(p,@""))where!new[]{p[0]^32^10}.Contains(i)select@i);

184 bytes colapsados, dejándote 17 bytes de espacio en blanco.

Solución agrietada usando el Concatmientras que mi solución prevista usaba Join, aquí está la solución prevista:

_=>string./**/
#if true
Join(/*"* //*/""/**//*/"* /",#elseConcat(//*/,
#endif
from m in" "let p=$@"{@"  "[1]}"from i in(_.Replace(p,@"
"))where!new[]{p[0]^32^10}.Contains(i)select@i);
Leche
fuente
Esto necesita c # 6+ para funcionar, ¿puede agregar eso?
TheLethalCoder
Esto ha sido resuelto por @Link Ng: codegolf.stackexchange.com/a/103233/38550
TheLethalCoder
5

MATL , 22 bytes. Agrietado y agrietado .

Este es un programa que toma entrada a través de STDIN y produce la salida a través de STDOUT.

Código sin espacios ni líneas nuevas:

t'@*'dm1e5%Mdw%Y(

El formato de entrada es un poco incómodo debido a cómo MATL toma la entrada de cadena. Las cadenas con líneas nuevas no se pueden ingresar directamente a través de STDIN, porque cada entrada debe ser una sola línea (la línea nueva marca el final de la entrada). Entonces el formato es el siguiente:

  1. Una cadena está entre comillas simples . Si el contenido de la cadena incluye comillas simples, se escapan duplicando . Ejemplo:'I''m a string'

  2. Para ingresar una cadena con líneas nuevas, se necesita dividir la cadena en líneas nuevas y concatenar todo (por medio de corchetes), incluidos los números como códigos ASCII . Por ejemplo, considere la cadena formada por mi nombre y apellido con una nueva línea en el medio. Sería ingresado como ['Luis' 10 'Mendo'].

    Esto permite ingresar cualquier otro código ASCII (posiblemente no imprimible). Entonces, la cadena en el elemento 1 anterior podría ingresarse alternativamente como ['I' 39 'm ' 97 32 'string']. Compruébalo aquí .

    La única condición es que al menos una de las partes dentro de los corchetes es una cadena. Eso obliga a que cualquier número se interprete como código ASCII cuando se concatena.

Perdón por lo incómodo ¡ Buena suerte con este formato!

Solución original

t' @ *'dm1e 5%
Mdw%Y
(

Cada uno %es un símbolo de comentario, por lo que se ignora el resto de la línea.

Los espacios no hacen nada, pero sirven como separadores. Por ejemplo, 1e5sin el espacio, se interpretaría como el número 100000.

t toma la entrada y la duplica.

' @ *'empuja esa cadena y dcalcula sus diferencias consecutivas, lo que da [32 -32 10](el -32es inútil).

mproporciona una matriz de filas lógica que indica qué caracteres son 32o 10(o -32).

1seguido de eremodelar como una fila. Esto es no-op aquí.

5seguido de Mempujes 1nuevamente (última entrada a la función de entrada múltiple más reciente, que es e).

dcalcula diferentes consecutivos de 1, y así da [](matriz vacía).

wintercambia y finalmente (asigna []caracteres de espacio en blanco, es decir, los elimina.

Luis Mendo
fuente
1
¡Estás mintiendo! ¡De ninguna manera esto funciona! (+1) ...
Stewie Griffin
2
¿agrietado?
MickyT
2
Mierda ... no me di cuenta de que ya estaba roto ... Bueno, doblemente roto .
Stewie Griffin
Buen trabajo los dos! :-) No es exactamente mi solución prevista, pero funciona perfectamente
Luis Mendo
4

RProgN , 15 bytes agrietados!

''`R""`R

Puedes jugar con el código aquí . Una solución relativamente simple, con suerte la naturaleza molesta de cómo RProgN maneja las cadenas dejará esto sin descifrar.

Programa original

' ' ` R
"
" ` R

Explicacion

En primer lugar, la entrada se empuja implícitamente a la pila. Apilar:<INPUT>

Luego, usamos '' para empujar un espacio a la pila. Apilar:<INPUT> " "

el `realmente intenta empujar una cadena representada por` (WORD) pero debido a que hay un espacio en blanco después, simplemente empuja una cadena vacía. Apilar:<INPUT> " " ""

La R aquí es azúcar para el comando Reemplazar. Apilar:<INPUTWITHOUTSPACES>

Luego, el "NEWLINE" empuja una cadena que contiene una nueva línea, lo cual es bueno porque RProgN no usa escapes, simplemente te permite empujar una cadena así. Apilar<INPUTWOSPACES> "\n"

Luego, usamos el `truco nuevamente, y Reemplazar, que da nuestra salida.

Un taco
fuente
¿Se supone que esto funciona en Firefox?
Conor O'Brien
Lo estoy ejecutando en Firefox, ¿hay algún problema? ¿Puedes obtener una captura de pantalla?
ATaco
Bueno, eso fue rápido. ¡Casi duraba media hora!
ATaco
4

Ruby, 86 bytes + 1 bandera = 87 ( descifrado por Dom Hastings )

Requiere bandera de línea de comando -p.

eval"(T$}{(!//;:678?32.&&)".gsub(/|(.)/){$1&&$&.ord.^($'.count('')).chr}

El código es realmente válido en este formulario, es solo un no-op.

histocrat
fuente
¡Esto es increíble, me encanta! Tan malo ...
Dom Hastings
¡Agrietado!
Dom Hastings
4

Haz , 72 bytes, ¡seguro!

Ahora para un lenguaje 2D. Se puede jugar con TIO Nexus .

s'''>`+++)+Ss`n\
 n`sS+(+++`<``/
 >rgn\
 ^ @<(\  
     H         <
 ^    /

Un programa bastante sencillo sin mucho para tratar de engañar a la gente.

s'''>`+++)+Ss`n\ # Sets the memory slot 0 to 0, 10 to 10 and 32 to 32. n will redirect down
 n`sS+(+++`<``/  # since memory != store. \ is a red herring and not hit.
 >rgn\           # read in from input and set store to memory value. For all characters
 ^ @<(\          # other than space, LF and end of input this will be different and n will 
     H         < # redirect down then through to the print and back to read. Space, LF and  
 ^    /          # end of input get directed to the ( which tests for 0. This will redirect 
                 # space and LF to path back to read, otherwise it will skip over and halt
MickyT
fuente
1
Creo que moveré el intérprete a Node cuando tenga tiempo para que Dennis pueda agregarlo a TIO ...
ETHproductions
1
¡He creado un clon Node del intérprete, y Dennis ahora lo ha agregado a TIO !
ETHproductions
4

Laberinto , 127 bytes

);""{"".@"-;,""""":"##"*"(:"+":}-;{";;"*#{:;"#""+("-;"";;"})"";""""""""

Espero haberlo hecho bien :) esta es mi primera entrada de policías y ladrones.

Código original

 ) ;""{"".@
"-;, "" ""
"  :
" ##
" *
" (:
"  +
"  :}-;{
"    ; ;
" *#{: ;
" #    "
" +("-;"
"    ; ;
"    })"
"      ;
""""""""
Robert Hickman
fuente
Su respuesta ahora es segura, puede agregar su código original y una explicación.
Laikoni
4

Java, 3241 + 28 bytes para una gran importación de enteros

Esta entrada es únicamente para demostrar la posibilidad de una entrada puramente criptográfica segura. Creo que esto está dentro de las reglas, pero si está en contra del espíritu, hágamelo saber y lo eliminaré por justicia. Dejaré esto "inseguro" indefinidamente hasta el momento en que (y si) se encuentre una grieta. Esto es una monstruosidad y seguramente podría optimizarse aún más, pero aquí está.

interfacer{staticvoidmain(String[]A){Strings=",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,",q=",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,",a="",b="";for(Stringt:s.split(",")){a+=t.length();}for(Stringt:q.split(",")){b+=t.length();}if((newBigInteger(a).multiply(newBigInteger(b)).toString()).equals("3649760552772806991406184564114682549877113954361462782925976763675666255653486225665808494957477900238166874367635068317805381406282572366371821972593595701388544127398102379288357379612333197280663769935384647844344358594407966485992727383589962048236726744715096711312156760311643104858212670342667229690568585229658813910569607411855770280546861422837629553847973043531578541545436967345783407835402474562087790816775240815912495599135241317")){System.out.println(A[0].replaceAll("","").replaceAll("\n",""));}}}

Para ser justos con los ladrones, aquí está todo con el espacio en blanco "obvio" agregado.

interface r {

    static void main(String[] A) {
        String s = ",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,", q = ",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,", a = "", b = "";
        for (String t : s.split(",")) {
            a += t.length();
        }
        for (String t : q.split(",")) {
            b += t.length();
        }
        if ((new BigInteger(a).multiply(new BigInteger(b)).toString()).equals("3649760552772806991406184564114682549877113954361462782925976763675666255653486225665808494957477900238166874367635068317805381406282572366371821972593595701388544127398102379288357379612333197280663769935384647844344358594407966485992727383589962048236726744715096711312156760311643104858212670342667229690568585229658813910569607411855770280546861422837629553847973043531578541545436967345783407835402474562087790816775240815912495599135241317")) {
            System.out.println(A[0].replaceAll("", "").replaceAll("\n", ""));
        }
    }
}

Buena suerte, me encantaría ver esto roto. De hecho, incluso instituiré una recompensa ilimitada por esto. Si en algún momento resuelves esto, se te otorgará un reconocimiento infinito de 500 repeticiones en el intercambio de fichas (así como probablemente un maravilloso papel matemático).


Rohan Jhunjhunwala
fuente
2
Su solución y la mía probablemente caminarán por las edades sin descifrar.
Joshua
1
Para el votante, ¿hay algo ilegítimo en esta sumisión?
Rohan Jhunjhunwala
1
En realidad, hay una solución trivial para esto (que no implica factorizar un número RSA-440 equivalente), por desgracia, requiere un extra ~ 10.000 bytes ...
SLuck49
1
@ SLuck49 ¿puedes comentarme?
Rohan Jhunjhunwala
1
@ SLuck49 wow! Me acabo de dar cuenta de lo que estabas mirando! Casi pierdo 500 reputación.
Rohan Jhunjhunwala
3

C, 140 bytes, descifrado por Riley

Comencemos con una fácil.

#include<stdio.h>intmain(){inta=getchar();while(a!=EOF){//\a=getchar();if(a!=10&&a!=32)//\\putchar(a^10^32);putchar(a);a=getchar();}}

(Espero estar haciendo esto bien).

Betseg
fuente
1
Agrietado. No es la solución indended ya que tengo 1 byte menos.
Riley
@Riley agrega una nueva línea adicional al final y estarás bien;)
Alfie Goodacre
2

V , 37 bytes Agrietado por nmjcman101

OVrS200@"kIi|D@"Aüî|D@"

Como esto no se puede imprimir, aquí está la versión legible:

O<esc>Vr<C-a>S200<esc>@"kIi<C-v><C-v><esc>|D@"<esc>Aüî<esc>|D@"

O si lo prefiere, un hexdump:

00000000: 4f1b 5672 0153 3230 301b 4022 6b49 6916  O.Vr.S200.@"kIi.
00000010: 161b 7c44 4022 1b41 fcee 1b7c 4440 22    ..|D@".A...|D@"
DJMcMayhem
fuente
Agrietada Eso fue un rompecabezas muy cool
nmjcman101
2

JavaScript ES6, 380 bytes, seguro

Este es el tipo de entrada que inicialmente estaba planeando lanzar. Es enorme y casi no tiene posibilidades de ganar, pero creo que debería ser criptográficamente lo suficientemente fuerte como para soportar 7 días. ¡Ahora, puedo estar equivocado!

67 bytes de espacio en blanco para agregar.

s=>{for(k=`|||`.split`|`.map(s=>s.replace(/\s/g,c=>(k-=(c<'')+1,n=n<<2|k&3),k=n=0)&&n),x=10106050295,y=-4955405499,i=32,d=2654435769,t=d*i;i--;y-=(x<<4^x>>>5)+x^t+k[t>>>11&3],t-=d,x-=(y<<4^y>>>5)+y^t+k[t&3]);returns[atob(([x,y].map(n=>String.fromCharCode(n&255,n>>8&255,n>>16&255,n>>24)).join``))](/[\n]/).join``}

Solución

Esta es una implementación del algoritmo extendido de cifrado minúsculo . La clave codificada en espacios en blanco de 64 bits se expande a la siguiente clave de 128 bits:

K = [0xd224de37, 0x89e34e79, 0xe34e7748, 0x939e2789]

ingrese la descripción de la imagen aquí

Fuente: Wikipedia

Una vez descifrado y convertido a ASCII, el bloque de 64 bits se [x, y]lee como c3BsaXQ=, que es la representación codificada de Base64 split.

Arnauld
fuente
1
Empecé con esta fuerza bruta, tal vez tendré suerte y tú hiciste que cada uno de los 4 valores clave tuviera la misma longitud (8 bits). Excepto que serían 16 bits cada uno ... woops. La fuerza bruta no va a suceder, es hora de otro enfoque.
SLuck49
2

Vitsy , 73 bytes, seguro

Esto es francamente malvado.

5mW3m7m7m2mD&EPamX}<m15mEnl9mZD\[4m]^P-cm(D_2-3*bmD1-dmrnu-'

¡Buena suerte! 13 elementos de espacio en blanco para agregar.

Código original:

5m
W3m7m
7m
2m
D&EPamX}
<m1
5mEn
l9mZ
D
\[4m]
^P-cm(D
_2-3*
bmD1-dmrnu-
'

Pruébalo en línea!

Esto se simplifica aproximadamente a:

<m1
W2\[2m]Z
l\[D&EP^P-_2-3*D1-rnu-(DX}]
Addison Crump
fuente
No mire el historial de edición, ya que tenía un error en mi código restante.
Addison Crump
No conoces el mal. Yo se el mal.
Joshua
Para mí son más de las 0300, así que agregaré una explicación por la mañana.
Addison Crump
1

C #, 159 bytes, agrietado por la leche

usingSystem.Linq;s=>string.Join("",string.Join("",s.Split(@"".Replace(newstring((char)0x0D,1),"").ToCharArray())).Select(c=>c+""!=""?c+"":"").ToArray());

153 colapsó, por lo que solo 6 bytes de espacio en blanco para encontrar no deberían ser demasiado difíciles ...

TheLethalCoder
fuente
1
Agrietado
leche
1

reticular, 43 bytes, agrietado

ISBqv<>>$$4jE:d/v$v?c+91d/v?E;!?l$/o$

La versión en TIO está desactualizada, pero puede obtener una copia del github .

Conor O'Brien
fuente
La versión en Nexus ya estaba actualizada. Me puse en v1 también.
Dennis
Simplemente comprobando, ¿funciona esto si la entrada contiene dos saltos de línea consecutivos?
Martin Ender
@MartinEnder debería. Depende de si la entrada se canaliza o no. Cuando se canaliza, debería leer todo el stdin.
Conor O'Brien
@ Dennis gracias! Quería preguntarte en el chat.
Conor O'Brien
Agrietado
James Holderness
1

Wolfram, 132

Probablemente tiene más de una solución (pista: Mersenne)

StringReplace[#,""->"",Limit[x/(x-1),x->Boole[PrimeQ[
212821282128228281282128228821282128212821282-1]]]]&

Solución

StringReplace[#," "->"",Limit[x/(x-1),x->Boole[PrimeQ[
2 128 2 128 2 128 2 2 8 2 8 128 2 128 2 2 8 8 2 128 2 128 2 128 2 128 2-1]]]]&
silbido
fuente
> Su envío será su código fuente con todos los espacios en blanco eliminados
Kritixi Lithos
@KritixiLithos Se elimina
swish
¿Qué pasa con los espacios antes de la segunda línea y la nueva línea entre la primera y la segunda línea?
Kritixi Lithos
Bueno, tienes razón, es solo por legibilidad ...
swish
Creo que puedes publicar la solución ahora.
CalculatorFeline
1

Espacio en blanco , 81 74 bytes

																					

Versión legible para humanos:

ttttttttttttttttttttt (21 tab characters)

Sé que este es un viejo desafío, pero espero que alguien esté dispuesto a intentar resolverlo. Intenté optimizar para bytecount pero es posible hacer algo más corto con la misma cantidad de caracteres de tabulación.

Ephphatha
fuente
0

tcc, 850 bytes

Para evitar pegar una línea muy larga, pasé esto a través de tr -d '\ n' | doblar -b -w 60.

#!/usr/bin/tcc-run#include<stdio.h>typedefunsignedcharu;um[]
={104,105,16,152,94,131,43,42,112,214,53,207,116,170,185,210
};intmain(){uS[256];uk[256];ui,j,t;intc,n=0;FILE*f;f=fopen(_
_FILE__,"r");/*cannotfail*/while(-1!=(c=fgetc(f)))if(c==''||
c==10)k[++n]=c;fclose(f);i=0;do{S[i]=i;}while(++i!=0);j=0;i=
0;do{j=j+S[i]+k[i%n];t=S[i];S[i]=S[j];S[j]=t;}while(++i!=0);
i=0;do{if(S[i]!=m[i])j=1;}while(++i<sizeof(m));if(j==1){i=0;
do{printf("%d,",(int)S[i]);}while(++i<sizeof(m));printf("\n"
);}else{while(-1!=(c=fgetc(stdin)))if(c!=''&&c!=10)fputc(c,s
tdout);}returnj;}
Joshua
fuente
Enlace al intérprete?
Addison Crump
@VoteToClose: apt-get install tcc lo hizo por mí.
Joshua
0

SILOS , 159 bytes ¡Seguro!

loadLinedef:lblgetagetzzzz/za=256:aX=getax=Xy=Xz=xx-10x|ifxbGOTOx:by-32y|ifycGOTOx:cprintCharX:xa+1z+1x=getaifxa:b

Debería ser bastante trivial. Es mi primera entrada de policías y ladrones.

Nadie lo atacó, probablemente debido a la naturaleza esotérica de mi propio idioma. Parece una forma sórdida de deslizarse, pero en realidad no importa, ya que las más cortas son seguras.

loadLine
def : lbl geta get z zz
z/z
a=256
:a
X=get a
x=X
y=X
z=x
x-10
x |
if x b
GOTO x
:b
y-32
y|
if y c
GOTO x
:c
printChar X
:x
a+1
z+ 1
x=get  a
if x a
:b

Siéntase libre de probarlo en línea

Rohan Jhunjhunwala
fuente