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>

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

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
}

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.

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

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

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.

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

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.

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.

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.

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

Laberinto , 127 bytes

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

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

Código original

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

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

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

Befunge 98, 65 bytes, descifrado por Pietu1998

~v>#@>::':'0--\'[';--!8v1+!*1+j!j,v>#@

Programa original

~v           >#@
 >::':'0--\'[';--!8v1+!
*1+j !j,     v     >
#@

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

Minkolang v0.15 , 88 bytes, ¡Agrietado!

$oI[dd""=$r'10'=1J,?1R]r$O3.14$$$Cdollars>$$$Ceverywhere>x

Pruébalo en línea!

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]

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.

let f =

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]);return s[atob(([x,y].map(n=>String.fromCharCode(n&255,n>>8&255,n>>16&255,n>>24)).join``))](/[ \n]/).join``}

console.log(f(`H e l l o
W o r l d`))

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}]

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

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 .

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]]]]&

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.

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;}

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