Pour les besoins de ce défi, nous allons définir les espaces blancs uniquement comme des sauts de ligne (0x0A) et des espaces (0x20). Notez que la plupart des langages et des variantes de regex considèrent de nombreux autres caractères comme des espaces aussi bien à l'intérieur qu'à l'extérieur de la plage ASCII, de sorte que vous ne pourrez peut-être pas utiliser les fonctions intégrées correspondantes.

Le défi des flics

Vous devez écrire un programme ou une fonction dans la langue de votre choix, qui prend en entrée une chaîne composée de caractères ASCII (à l'exception de NUL) et le renvoie en supprimant tous les espaces. Par exemple, si vous avez reçu les données suivantes:

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

Vous devriez sortir

Hello,World!

Votre soumission sera alors votre code source avec tous les espaces supprimés (le même processus consiste à transmettre votre solution en tant qu'entrée, bien que votre solution puisse également contenir des caractères en dehors de la plage ASCII). Votre objectif est de rendre aussi difficile que possible de déterminer où des espaces doivent être insérés pour retrouver une solution valide dans la langue de votre choix. Notez que les cambrioleurs peuvent insérer moins d’espaces que vous en avez supprimés, mais pas plus. Rappelez-vous également que les voleurs ne doivent pas correspondre exactement à votre code, ils doivent simplement trouver une solution valable.

Votre réponse devrait contenir les éléments suivants:

• La langue (et la version si nécessaire) dans laquelle vous avez écrit votre solution.
• Nombre d'octets de votre solution avant de supprimer les espaces.
• Votre solution avec les espaces blancs supprimés.

Votre solution peut être un programme ou une fonction, mais pas un extrait et vous ne devez pas assumer un environnement REPL. Vous pouvez effectuer une entrée via STDIN, un argument de ligne de commande ou une fonction, et une sortie via STDOUT, une valeur de retour de fonction ou un paramètre de fonction (out).

Dans un souci d'équité, il doit exister un interprète ou un compilateur librement disponible pour la langue de votre choix.

Vous ne devez pas utiliser les fonctions intégrées pour le hachage, le chiffrement ou la génération de nombres aléatoires (même si vous générez le générateur de nombres aléatoires à une valeur fixe). Votre solution doit pouvoir traiter toute chaîne de 100 caractères ou moins en moins de 10 secondes sur un ordinateur de bureau raisonnable.

Si votre réponse n'a pas été fissurée dans les 7 jours (168 heures), vous pouvez révéler votre propre solution, point auquel votre réponse est considérée comme sûre . Tant que vous ne révélez pas votre solution, les voleurs peuvent la craquer, même si les 7 jours sont déjà écoulés. La réponse sûre la plus courte l'emporte (mesurée avant la suppression des espaces).

Si votre réponse est déchirée, veuillez l'indiquer dans l'en-tête de votre réponse, avec un lien vers la réponse du voleur correspondant.

Allez ici pour la partie des voleurs.

Soumissions non fissurées

<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 octets, fissuré par nimi

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

C'est un programme complet et un poème dadaïste.

Code with withspace (Essayez-le en ligne!)

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

^{J'ai toujours l'air assez poétique, si vous me le demandez.}

Désobfus

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

Explication

La do-notation est seulement un sucre syntaxique, donc fon peut écrire de manière équivalente

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

Pour les listes, l' >>=opérateur est défini comme concatMap, fdevient ainsi

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

Donc, dans le cas d’une entrée "a b\nc", linesdivise l’entrée aux nouvelles lignes ["a b","c"], wordschaque ligne à l’espace vide [["a","b"],["c"]](comme je viens de le comprendre, cela inclut les nouvelles lignes, donc ce linesn’est pas nécessaire). La concaténation donne une fois ["a","b","c"], idest la fonction identité et, en tant que telle, n’a aucun effet et la concaténation finale produit la chaîne "abc".

C, 475 octets, fissuré par Riley

Certaines parties de C rendent vraiment très facile de voir où les espaces doivent aller. Le pré-processeur c, cependant, ne le fait pas. Donc, ce code est en quelque sorte en deux moitiés: jusqu'à la ligne 17 (236 caractères avec des espaces), le code est pratiquement non-obscurci, et après cela (239 caractères avec des espaces), bonne chance!

Je ne vais pas gagner cette compétition de loin, mais je voulais voir ce qui pouvait être fait avec le pré-processeur 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}

Compile (avec des avertissements, si vous les activez) avec gcc -std=c89 -ansiet fonctionne commecat file | ./a.out

Cela a été craqué beaucoup plus rapidement que je pensais, félicitations! Ma stratégie consistait à utiliser #definespour supprimer les limites de jetons évidentes (comme ';'), puis à en utiliser davantage #definespour rendre VRAIMENT simple la façon dont elles étaient mélangées.

En passant, voici à quoi ressemble le code après avoir uniquement ajouté les espaces évidents:

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

Octave, 69 octets, SAFE!

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

Format de saisie: les nouvelles lignes ne peuvent pas être saisies directement dans l'invite de commande. Créez la chaîne par concaténation comme ceci:

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

Appelez la fonction comme ceci (ajoutez des espaces):

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

Code d'origine:

Il ne vous fallait que 66 octets pour que cela fonctionne, mais j’en ai écrit 69 dans l’en-tête afin de ne pas divulguer trop d’informations.

Le code original ressemble à ceci:

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

Explication:

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

Uest un point de code 85dans la table ASCII, il semblerait donc que le premier espace devrait être après 85. Faux!

Si nous insérons l’espace après 853, nous devrions obtenir le numéro du caractère 853, non ..? Utiliser charpour vérifier si c'est un caractère reconnaissable:

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

Cependant, nous n'utilisons pas chardans le code, nous utilisons la version plus courte dans laquelle nous concaténons les nombres avec une chaîne vide [853 '']. Au lieu de donner une erreur hors de portée, la version la plus courte prend simplement le module de nombres 256.

C'est ce qui est arrivé 85+3*256 = 853. Alors que char(853)donne un avertissement, [853,'']retourne U.

La manière évidente de faire cette tâche dans Octave est la suivante:

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

Nous savons qu'il doit y avoir une parenthèse ouvrante (point de code 40) après la première U. 29ne convient évidemment pas alors nous déplaçons l'espace un autre droit et obtenons 296. mod(296,256) = 40. Bingo!

Continuez comme ça et terminez avec la séquence:

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

Enfin, nous utilisons evalpour transformer la chaîne en code.

JavaScript ES6, 199 octets, fissuré par SLuck49

Une entrée plutôt volumineuse avec 33 octets de blancs à ajouter.

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

> <>, 40 octets, fissuré par le pélican

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

J'ai utilisé fishlanguage.com , juste au cas où il y aurait des différences entre les interprètes.

Befunge-93, 58 bytes, Safe!

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

Essayez-le en ligne!

Programme original

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

Essayez-le en ligne!

Le truc, c’est que le chemin d’exécution était plus vertical que horizontal, puis divers espaces ont été insérés au hasard dans le code pour mieux mélanger les chemins verticaux. Une fois que la ligne a été rompue et que les espaces ont finalement été supprimés, il ne restait que très peu, espérons-le, pour indiquer les relations entre les opérations.

Au cas où cela ne soit pas assez difficile, j'ai également ajouté un peu d'entrelacement afin qu'un certain nombre d'opérations aient été exécutées par différents chemins de code s'écoulant perpendiculairement. L'idée est que si vous pensiez avoir trouvé la bonne position pour une commande particulière, vous ne réaliseriez pas que vous pourriez avoir besoin de la réutiliser plus tard dans le code.

Je ne sais pas si cela a valu la peine de faire tous ces efforts pour essayer de rendre les choses compliquées ou si les gens ne se sont même pas donné la peine d'essayer de le résoudre. :)

Explication du code

_      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 octets, fissuré par Link Ng

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

184 octets ont été réduits, ce qui vous laisse 17 octets d’espace.

Solution fissurée utilisant la solution Concatque ma solution envisagée utilisait Join, voici la solution envisagée:

_=>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 octets. Fissuré et fissuré .

C'est un programme qui prend une entrée via STDIN et produit la sortie via STDOUT.

Code sans espaces ni nouvelles lignes:

t'@*'dm1e5%Mdw%Y(

Le format de saisie est un peu délicat à cause de la façon dont MATL prend la saisie de chaîne. Les chaînes avec des nouvelles lignes ne peuvent pas être entrées directement via STDIN, car chaque entrée doit être une ligne unique (la nouvelle ligne marque la fin de la saisie). Le format est donc le suivant:

1. Une chaîne est entourée de guillemets simples . Si le contenu de la chaîne comprend des guillemets simples, ils sont évités par la duplication . Exemple:'I''m a string'

2. Pour entrer une chaîne avec des nouvelles lignes, il faut la scinder à la nouvelle ligne et tout concaténer (au moyen de crochets), y compris les nombres en tant que codes ASCII . Par exemple, considérons la chaîne formée par mes prénom et nom avec une nouvelle ligne entre les deux. Ce serait entré comme ['Luis' 10 'Mendo'].

   Cela permet de saisir tout autre code ASCII (éventuellement non imprimable). Ainsi, la chaîne du point 1 ci-dessus peut être entrée alternativement ['I' 39 'm ' 97 32 'string']. Vérifiez ici .

   La seule condition est qu'au moins une des parties entre crochets soit une chaîne. Cela oblige tous les nombres à être interprétés comme des codes ASCII lors de la concaténation.

Désolé pour la maladresse Bonne chance en utilisant ce format!

Solution originale

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

Chacun %est un symbole de commentaire, le reste de la ligne est donc ignoré.

Les espaces ne font rien mais servent de séparateurs. Par exemple, 1e5sans espace, serait interprété comme un nombre 100000.

t prend l'entrée et la duplique.

' @ *'pousse cette chaîne, et dcalcule ses différences consécutives, ce qui donne [32 -32 10](le -32est inutile).

mdonne un tableau de rangée logique indiquant quels caractères sont 32ou 10(ou -32).

1suivi de eremodeler en rangée. Ceci est no-op ici.

5suivi d'une nouvelle Mpression 1(dernière entrée de la fonction d'entrée multiple la plus récente, à savoir e).

dcalcule les différences consécutives de 1, et donne donc [](tableau vide).

wswaps, et enfin (assigne []aux caractères d'espacement, c'est-à-dire les supprime.

RProgN , 15 octets craqués!

''`R""`R

Vous pouvez jouer avec le code ici . Une solution relativement simple, espérons que la nature agaçante de la façon dont RProgN gère les chaînes laissera celle-ci sans rien faire.

Programme original

' ' ` R
"
" ` R

Explication

Premièrement, l'entrée est implicitement poussée dans la pile. Empiler:<INPUT>

Ensuite, nous utilisons '' pour placer un espace dans la pile. Empiler:<INPUT> " "

le `essaie réellement de pousser une chaîne représentée par` (WORD) mais parce qu'il y a un espace après, il pousse juste une chaîne vide. Empiler:<INPUT> " " ""

Le R ici est le sucre pour la commande Remplacer. Empiler:<INPUTWITHOUTSPACES>

Ensuite, "NEWLINE" pousse une chaîne contenant une nouvelle ligne, ce qui est bien, car RProgN n'utilise pas de caractères d'échappement, mais vous permet de pousser une chaîne comme celle-ci. Empiler<INPUTWOSPACES> "\n"

Ensuite, nous utilisons l’astuce à nouveau, et Replace, qui donne notre sortie.

Ruby, 86 octets + 1 drapeau = 87 ( fissuré par Dom Hastings )

Nécessite un indicateur de ligne de commande -p.

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

Le code est en fait valide sous cette forme, c'est juste un no-op.

Faisceau , 72 octets, sûr!

Maintenant pour une langue 2D. Peut être joué avec TIO Nexus .

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

Un programme assez simple sans beaucoup d'essayer de tromper les gens.

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

Labyrinthe , 127 octets

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

Espérons que je l'ai bien fait :) C'est ma première entrée dans la liste des flics et des voleurs.

Code d'origine

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

Java, 3241 + 28 octets pour une grande importation Integer

Cette entrée est uniquement destinée à prouver la possibilité d’une entrée purement cryptographique. Je crois que cela respecte les règles, mais si cela va à l’encontre de l’esprit, faites-le-moi savoir et je supprimerai par souci d’équité. Je laisserai ce "dangereux" indéfiniment jusqu'au moment où (et si) une fissure sera trouvée. Ceci est une monstruosité et pourrait sûrement être optimisé, mais le voici.

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

Par souci d'équité pour les voleurs, la voici avec tous les espaces "évidents" ajoutés.

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

Bonne chance, j'aimerais voir cette fissure. En fait, je vais même instituer une prime illimitée à ce sujet. Si, à un moment donné, vous craignez cela, vous recevrez une récompense infinie de 500 représentants pour un échange de pile (et probablement un excellent document mathématique).

C, 140 octets, fissuré par Riley

Commençons par un 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();}}

(J'espère que je le fais bien.)

Befunge 98, 65 octets, fissuré par Pietu1998

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

Programme original

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

V , 37 octets Fissuré par nmjcman101

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

Puisque cela a des imprimables, voici la version lisible:

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

Ou si vous préférez, 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 octets, fissuré!

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

Essayez-le en ligne!

JavaScript ES6, 380 octets, sûr

C'est le genre d'entrée que je prévoyais initialement de publier. C'est énorme et n'a presque aucune chance de gagner, mais je pense qu'il devrait être suffisamment fort sur le plan cryptographique pour résister à 7 jours. Maintenant, il se peut que je me trompe!

67 octets de blancs à ajouter.

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

Solution

Ceci est une implémentation de l' algorithme Extended Tiny Encryption . La clé codée en espace de 64 bits se développe en la clé suivante de 128 bits:

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

Source: Wikipedia

Une fois déchiffré et converti en ASCII, le bloc de 64 bits se [x, y]lit comme c3BsaXQ=, ce qui correspond à la représentation codée en Base64 de 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 octets, coffre-fort

C'est carrément mauvais.

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

Bonne chance! 13 éléments d'espaces à ajouter.

Code d'origine:

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

Essayez-le en ligne!

Cela simplifie grossièrement jusqu'à:

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

C #, 159 octets, craquelé par du lait

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

153 collaps donc 6 octets de blancs à trouver ne devraient pas être trop durs ...

réticulaire, 43 octets, fissuré

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

La version sur TIO est obsolète, mais vous pouvez vous en procurer une copie à partir du github .

Wolfram, 132

A probablement plus d'une solution (indice: Mersenne)

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

Solution

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

Espace blanc , 81 à 74 octets

Version lisible par l'homme:

ttttttttttttttttttttt (21 tab characters)

Je sais que c'est un vieux défi, mais j'espère que quelqu'un sera prêt à tenter sa chance. J'ai essayé d'optimiser le décompte, mais il serait peut-être possible de faire quelque chose de plus court avec le même nombre de caractères de tabulation.

tcc, 850 octets

Pour éviter de coller une très longue ligne, je l’ai passée par tr -d '\ n' | fold -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 octets Sûr!

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

Devrait être assez trivial. C'est ma première entrée de flics et de voleurs.

Personne ne l'a attaqué, probablement en raison de la nature ésotérique de mon propre langage. Cela peut sembler une façon louche de glisser, mais cela n’a pas d’importance, car les plus courtes sont sûres.

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

N'hésitez pas à l' essayer en ligne