Ai fini di questa sfida, definiremo gli spazi bianchi solo come avanzamenti di riga (0x0A) e spazi (0x20). Nota che la maggior parte delle lingue e dei sapori regex considerano molti altri caratteri anche come spazi bianchi, sia all'interno che all'esterno dell'intervallo ASCII, quindi potresti non essere in grado di utilizzare i built-in corrispondenti.

La sfida della polizia

Dovresti scrivere un programma o una funzione in una lingua a tua scelta, che accetta una stringa, composta da caratteri ASCII (tranne NUL), come input e output con tutto lo spazio bianco rimosso. Ad esempio se hai ricevuto il seguente input:

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

Dovresti produrre

Hello,World!

Il tuo invio sarà quindi il tuo codice sorgente con tutto lo spazio bianco rimosso (lo stesso processo del passaggio della soluzione come input a se stesso, sebbene la soluzione possa contenere anche caratteri al di fuori dell'intervallo ASCII). Il tuo obiettivo è quello di rendere il più difficile possibile capire dove inserire gli spazi bianchi per recuperare una soluzione valida nella tua lingua preferita. Nota che i ladri possono inserire meno spazi bianchi di quelli che hai rimosso, ma non di più. Ricorda inoltre che i ladri non devono corrispondere al tuo codice esatto, devono solo trovare una soluzione valida.

La tua risposta dovrebbe contenere quanto segue:

• La lingua (e la versione se necessario) in cui hai scritto la tua soluzione.
• Il conteggio dei byte della soluzione prima di rimuovere gli spazi bianchi.
• La tua soluzione con spazi bianchi rimossa.

La soluzione può essere un programma o una funzione, ma non uno snippet e non è necessario assumere un ambiente REPL. È possibile accettare input tramite STDIN, argomento della riga di comando o argomento della funzione e output tramite STDOUT, valore di ritorno della funzione o parametro di funzione (out).

Nell'interesse dell'equità, ci deve essere un interprete o un compilatore liberamente disponibile per la lingua scelta.

Non è necessario utilizzare gli incorporamenti per hash, crittografia o generazione di numeri casuali (anche se si semina il generatore di numeri casuali su un valore fisso). La tua soluzione deve essere in grado di elaborare qualsiasi stringa di 100 caratteri o meno in meno di 10 secondi su una macchina desktop ragionevole.

Se la tua risposta non è stata decifrata entro 7 giorni (168 ore), puoi rivelare la tua soluzione a quel punto la tua risposta è considerata sicura . Fintanto che non rivelerai la tua soluzione, potrebbe essere comunque violata dai ladri, anche se i 7 giorni sono già passati. Vince la risposta sicura più breve (misurata prima di rimuovere gli spazi bianchi).

Se la tua risposta viene decifrata, ti preghiamo di indicarla nell'intestazione della tua risposta, insieme a un link alla risposta del ladro corrispondente.

Vai qui per la parte dei ladri.

Contributi non crackati

<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 byte, rotto da nimi

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

Questo è un programma completo e una poesia dadaistica.

Codice con withspace (provalo online!)

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

^{Sembra ancora piuttosto poetico, se me lo chiedi.}

De-offuscato

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

Spiegazione

La donotazione è solo zucchero sintattico, quindi fpuò equivalentemente essere scritta come

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

Per gli elenchi, >>=-operator è definito come concatMap, così fdiventa

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

Quindi, dato un input "a b\nc", linesdivide l'input a newline ["a b","c"], wordsdivide ogni riga allo spazio bianco cedendo [["a","b"],["c"]](come ho capito solo ora questo include newline, quindi in linesrealtà non è necessario). Concatenare una volta dà ["a","b","c"], idè la funzione identità e come tale non ha alcun effetto e la concatenazione finale produce la stringa "abc".

C, 475 byte, rotto da Riley

Alcune parti di C rendono davvero facile vedere dove dovrebbero andare gli spazi bianchi. Il pre-processore c, tuttavia, non lo fa. Quindi questo codice è in una specie di due metà: fino alla riga 17 (236 caratteri con spazi bianchi) il codice è praticamente non offuscato, e dopo (239 caratteri con spazi bianchi), buona fortuna!

Non vincerò questa competizione da molto tempo, ma volevo vedere cosa si poteva fare con il pre-processore 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 avvisi, se li abiliti) con gcc -std=c89 -ansie funziona comecat file | ./a.out

Questo è stato risolto molto più velocemente di quanto pensassi, complimenti! La mia strategia era quella di usare #definesper rimuovere i confini di token evidenti (come ';') e quindi usarne di più #definesper renderlo DAVVERO poco intuitivo su come venivano mescolati.

Questo, a proposito, è come appare il codice dopo che è stato aggiunto solo l'ovvio spazio bianco:

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

Ottava, 69 byte, SICURO!

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

Formato di input: Newline non può essere immesso direttamente nel prompt dei comandi. Crea la stringa per concatenazione in questo modo:

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

Chiama la funzione in questo modo (aggiungi spazi bianchi):

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

Codice originale:

Avevi bisogno solo di 66 byte per farlo funzionare, ma ho scritto 69 nell'intestazione per non dare troppe informazioni.

Il codice originale è simile al seguente:

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

Spiegazione:

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

Uè il punto di codice 85nella tabella ASCII, quindi sembrerebbe come dovrebbe essere il primo spazio dopo 85. Sbagliato!

Se invece inseriamo lo spazio dopo 853, dovremmo ottenere il numero di carattere 853, giusto ..? Usando charper verificare se si tratta di un personaggio riconoscibile:

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

Tuttavia, non usiamo charnel codice, usiamo la versione più breve in cui concateniamo i numeri con una stringa vuota [853 '']. Invece di dare un errore fuori portata, la versione più breve prende semplicemente il modulo di numeri 256.

È proprio così 85+3*256 = 853. Mentre char(853)dà un avviso, [853,'']ritorna U.

Il modo ovvio per eseguire questa attività in Octave è:

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

Sappiamo che ci deve essere una parentesi aperta (codice punto 40) dopo la prima U. 29ovviamente non si adatta, quindi spostiamo lo spazio ancora più a destra e otteniamo 296. mod(296,256) = 40. Bingo!

Continua così e finisci con la sequenza:

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

Infine, usiamo evalper trasformare la stringa in codice.

JavaScript ES6, 199 byte, crackato da SLuck49

Una voce piuttosto voluminosa con 33 byte di spazio bianco da aggiungere.

s=>eval(atob`ISYgJiAtOkI8Qk97BRBeaxZFShoUZSsiOGkMenNy`.replace(/./g,(c,i)=>String.fromCharCode(c.charCodeAt()^(k+="SecretCode".split(/\w/)[i%11].length)),k=0)).join``

> <>, 40 byte, incrinato dal pellicano verde acqua

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

A proposito, ho usato fishlanguage.com , nel caso in cui ci siano differenze tra gli interpreti.

Befunge-93, 58 byte, sicuro!

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

Provalo online!

Programma originale

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

Provalo online!

Il trucco era che il percorso di esecuzione era più verticale che orizzontale, quindi vari spazi venivano inseriti casualmente nel codice per mescolare ulteriormente i percorsi verticali. Una volta che la linea si interrompe e gli spazi bianchi sono stati finalmente rimossi, si spera che ci sia molto poco per indicare come le operazioni si relazionano tra loro.

Nel caso in cui ciò non fosse abbastanza difficile, ho anche inserito un po 'di interfogliatura, quindi un certo numero di operazioni sono state eseguite da percorsi di codice diversi che scorrevano perpendicolarmente l'uno all'altro. L'idea è che se pensassi di aver trovato la posizione corretta per un determinato comando, non ti renderesti conto che potrebbe essere necessario utilizzarlo di nuovo più avanti nel codice.

Non sono sicuro se valesse la pena di provare a complicare le cose, o le persone non si sono nemmeno preoccupate di cercare di risolverle. :)

Spiegazione del codice

_      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 byte, crackato da Link Ng

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

184 byte sono crollati, lasciandoti 17 byte di spazio bianco.

Soluzione incrinata usando il Concatmentre la mia soluzione prevista usava la Join, ecco la soluzione 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 byte. Incrinato e incrinato .

Questo è un programma che accetta input tramite STDIN e produce output tramite STDOUT.

Codice senza spazi o newline:

t'@*'dm1e5%Mdw%Y(

Il formato di input è un po 'imbarazzante a causa del modo in cui MATL accetta l'input di stringhe. Le stringhe con newline non possono essere immesse direttamente tramite STDIN, poiché ogni input deve essere una singola riga (newline segna la fine dell'input). Quindi il formato è il seguente:

1. Una stringa è racchiusa tra virgolette singole . Se il contenuto della stringa include virgolette singole, queste vengono salvate duplicando . Esempio:'I''m a string'

2. Per inserire una stringa con newline è necessario dividere la stringa in newline e concatenare tutto (mediante parentesi quadre), compresi i numeri come codici ASCII . Ad esempio, considera la stringa formata dal mio nome e cognome con una nuova riga in mezzo. Sarebbe inserito come ['Luis' 10 'Mendo'].

   Ciò consente di inserire qualsiasi altro codice ASCII (possibilmente non stampabile). Quindi la stringa nell'elemento 1 sopra potrebbe essere inserita alternativamente come ['I' 39 'm ' 97 32 'string']. Controlla qui .

   L'unica condizione è che almeno una delle parti tra parentesi sia una stringa. Ciò costringe qualsiasi numero ad essere interpretato come codice ASCII durante la concatenazione.

Mi dispiace per l'imbarazzante Buona fortuna con questo formato!

Soluzione originale

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

Ciascuno %è un simbolo di commento, quindi il resto della riga viene ignorato.

Gli spazi non fanno nulla, ma servono come separatori. Ad esempio, 1e5senza lo spazio, verrebbe interpretato come il numero 100000.

t prende l'input e lo duplica.

' @ *'spinge quella stringa e dcalcola le sue differenze consecutive, il che dà [32 -32 10]( -32è inutile).

mfornisce un array di righe logico che indica quali caratteri sono 32o 10(o -32).

1seguito da erimodella come una riga. Questo non è operativo qui.

5seguito da Mpush di 1nuovo (ultimo input alla funzione di input multiplo più recente, ovvero e).

dcalcola differenze consecutive di 1, e quindi dà [](matrice vuota).

wscambia e infine (assegna []a caratteri spazi bianchi, cioè li rimuove.

RProgN , 15 byte incrinati!

''`R""`R

Puoi giocare con il codice qui . Una soluzione relativamente semplice, si spera che la natura fastidiosa di come RProgN gestisce le stringhe lascerà questo incrinato.

Programma originale

' ' ` R
"
" ` R

explination

Innanzitutto, l'input viene implicitamente inserito nello stack. Pila:<INPUT>

Quindi, usiamo '' per spingere uno spazio nello stack. Pila:<INPUT> " "

il `in realtà cerca di spingere una stringa rappresentata da` (WORD) ma poiché c'è spazio dopo, spinge semplicemente una stringa vuota. Pila:<INPUT> " " ""

La R qui è zucchero per il comando Sostituisci. Pila:<INPUTWITHOUTSPACES>

Successivamente, "NEWLINE" invia una stringa contenente una nuova riga, il che è carino perché RProgN non usa escape, ma semplicemente verso l'alto ti consente di inserire una stringa del genere. Pila<INPUTWOSPACES> "\n"

Quindi, usiamo di nuovo il trucco e Sostituisci, che fornisce il nostro output.

Rubino, 86 byte + 1 bandiera = 87 ( incrinato da Dom Hastings )

Richiede il flag della riga di comando -p.

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

Il codice è in realtà valido in questo modulo, è solo una no-op.

Fascio , 72 byte, sicuro!

Ora per una lingua 2d. Può essere giocato con su TIO Nexus .

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

Un programma abbastanza diretto senza molto in là per cercare di ingannare 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

Labirinto , 127 byte

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

Spero di averlo fatto bene :) questa è la mia prima voce su poliziotti e ladri.

Codice originale

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

Java, 3241 + 28 byte per una grande importazione di numeri interi

Questa voce serve solo a dimostrare la possibilità di una voce puramente crittograficamente sicura. Credo che questo rientri nelle regole, ma se è contro lo spirito, per favore fatemi sapere e cancellerò per equità. Lascerò questo "insicuro" indefinitamente fino a quando non si troverà (e se) una crepa. Questa è una mostruosità e potrebbe sicuramente essere ulteriormente ottimizzata, ma eccola qui.

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",""));}}}

Per equità nei ladri, eccolo qui con l'aggiunta di tutti gli spazi "ovvi".

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", ""));
        }
    }
}

Buona fortuna, mi piacerebbe vederlo rotto. In effetti, istituirò persino una generosità illimitata su questo. Se in qualsiasi momento lo risolvi, ti verrà assegnato un riconoscimento infinito di 500 rappresentanti sullo scambio di pile (e probabilmente anche un meraviglioso documento matematico).

C, 140 byte, incrinato da Riley

Cominciamo con uno facile.

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

(Spero di farlo bene.)

Befunge 98, 65 byte, incrinato da Pietu1998

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

Programma originale

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

V , 37 byte Incrinato da nmjcman101

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

Dal momento che questo non è stampabile, ecco la versione leggibile:

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

O se preferisci, 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 byte, Cracked!

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

Provalo online!

JavaScript ES6, 380 byte, sicuro

Questo è il tipo di voce che inizialmente avevo intenzione di rilasciare. È enorme e non ha quasi alcuna possibilità di vincere, ma penso che dovrebbe essere crittograficamente abbastanza forte da resistere a 7 giorni. Ora, potrei essere smentito!

67 byte di spazi bianchi da aggiungere.

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

Soluzione

Questa è un'implementazione dell'Algoritmo di crittografia minuscola estesa . La chiave con codifica degli spazi bianchi a 64 bit si espande alla seguente chiave a 128 bit:

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

Fonte: Wikipedia

Una volta decodificato e convertito in ASCII, il blocco a 64 bit [x, y]legge come c3BsaXQ=, che è la rappresentazione codificata Base64 di 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 byte, sicuro

Questo è decisamente malvagio.

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

In bocca al lupo! 13 elementi di spazi bianchi da aggiungere.

Codice originale:

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

Provalo online!

Questo semplifica all'incirca fino a:

<m1
W2\[2m]Z
l\[D&EP^P-_2-3*D1-rnu-(DX}]

C #, 159 byte, Incrinato dal latte

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

153 è crollato, quindi solo 6 byte di spazio bianco da trovare, non dovrebbero essere troppo difficili ...

reticolare, 43 byte, incrinato

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

La versione su TIO è obsoleta, ma puoi procurartene una copia da Github .

Wolfram, 132

Probabilmente ha più di una soluzione (suggerimento: Mersenne)

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

Soluzione

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

Spazio bianco , 81 74 byte

Versione leggibile dall'uomo:

ttttttttttttttttttttt (21 tab characters)

So che questa è una vecchia sfida, ma spero che qualcuno sia disposto a provare a risolverlo. Ho tentato di ottimizzare per bytecount ma potrebbe essere possibile rendere qualcosa di più breve con lo stesso numero di caratteri di tabulazione.

tcc, 850 byte

Per evitare di incollare una linea molto lunga ho passato questo attraverso tr -d '\ n' | piega -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 byte Sicuro!

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

Dovrebbe essere abbastanza banale. È la mia prima voce su poliziotti e ladri.

Nessuno l'ha attaccato, probabilmente a causa della natura esoterica della mia lingua. Sembra un modo squallido di scivolare, ma non importa perché quelli più corti sono sicuri.

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

Sentiti libero di provarlo online