Espaces blancs significatifs: flics

51

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>

Martin Ender
la source
Apparenté, relié, connexe. (Inspiration, en fait.)
Martin Ender
7
On dirait que Whitespace relèverait ce défi ...
NoOneIsHere
8
@SeeOneRhino Pourquoi? Le voleur doit simplement résoudre le problème dans les espaces blancs, sans utiliser plus d'octets que le flic. À moins qu'un policier ne trouve une réponse à Whitespace complètement folle au golf, que personne ne peut égaler, les réponses à Whitespace sont généralement les plus vulnérables face à ce défi.
Martin Ender
1
@SeeOneRhino De plus, les tabulations ne sont pas considérées comme des espaces, elles ne seront donc pas supprimées.
mbomb007
4
Aucune soumission hexagone cette fois, je suppose
MildlyMilquetoast

Réponses:

17

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

Laikoni
la source
3
Est - ce que je dois dire que j'aime dadaïstes poèmes ISTIC?
Dada
1
ma conjecture
nimi
@nimi oui, bien fait.
Laikoni
12

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
}
Rexroni
la source
5
Bienvenue chez PPCG! :)
Martin Ender
1
Cracked Cela à sens unique est vraiment amusant.
Riley
9

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.

Stewie Griffin
la source
3
+1 pour expliquer le format de saisie sur 2 lignes alors qu'il me fallait 10 :-D
Luis Mendo
1
Eh bien, toujours aucune idée, sauf que maintenant je reconnais une lettre Uparmi ce groupe de chiffres :-)
Luis Mendo
2
Très bon truc! C'est fou qu'Octave le fasse avec des codes de caractères. Je n'en avais aucune idée. Mais alors, à quoi pouvez-vous vous attendre quand le doc officiel dit qu'Octave supporte Unicode par accident ... :-P
Luis Mendo
7

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``
Arnauld
la source
Nice one .. Je suppose que nous devons ajouter la quantité appropriée d'espaces à "SecretCode" afin de chiffrer la chaîne cryptée et d'obtenir la source appropriée ~
Patrick Roberts
@ PatrickRoberts Oui, exactement.
Arnauld
J'ai déjà un script automatisé testant toutes les combinaisons possibles, ce n'est qu'une question de temps ... se tord les mains, sachant que son plan diabolique fonctionne
Patrick Roberts
Ouf ... cela prend plus de temps que je pensais. Je pense écrire un défi de code-golf pour calculer le nombre de permutations possibles, étant donné un tableau de longueur N et une somme S à laquelle les éléments doivent correspondre. En ce moment, je suis à [ 10, 0, 0, 0, 0, 9, 8, 1, 5, 0, 0 ]la séquence d'intervalle et ma fonction d'itération au tableau est (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}}. J'ai commencé à [ 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ].
Patrick Roberts
6

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

DanTheMan
la source
3
Cracked
Teal Pelican
6

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.
James Holderness
la source
5

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);
Lait
la source
Cela nécessite c # 6+ pour fonctionner, pouvez-vous l'ajouter?
TheLethalCoder
Cela a été résolu par @Link Ng: codegolf.stackexchange.com/a/103233/38550
TheLethalCoder
5

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.

Luis Mendo
la source
1
Tu ment! Pas du tout, ça marche! (+1) ...
Stewie Griffin
2
fissuré?
MickyT
2
Merde ... Je n'ai pas remarqué que c'était déjà fissuré ... Eh bien, double craquage .
Stewie Griffin
Beau travail à tous les deux! :-) Pas exactement la solution que je voulais mais ça marche parfaitement
Luis Mendo
4

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.

ATaco
la source
Est-ce que cela est supposé fonctionner dans Firefox?
Conor O'Brien
Je l'exécute dans firefox, y a-t-il un problème? Pouvez-vous obtenir une capture d'écran?
ATaco
fissuré?
MickyT
Eh bien c'était rapide. J'ai failli durer une demi-heure!
ATaco
4

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.

histocrate
la source
C'est génial, j'adore! Si méchant ...
Dom Hastings
Fissuré!
Dom Hastings
4

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
MickyT
la source
1
Je pense que je déplacerai l'interprète vers Node lorsque j'en aurai le temps afin que Dennis puisse l'ajouter à TIO ...
ETHproductions
1
J'ai créé un clone de nœud de l'interprète, et Dennis l'a maintenant ajouté à TIO !
ETHproductions
4

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

 ) ;""{"".@
"-;, "" ""
"  :
" ##
" *
" (:
"  +
"  :}-;{
"    ; ;
" *#{: ;
" #    "
" +("-;"
"    ; ;
"    })"
"      ;
""""""""
Robert Hickman
la source
Votre réponse est maintenant sûre, vous pouvez ajouter votre code d'origine et une explication.
Laikoni
4

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


Rohan Jhunjhunwala
la source
2
Votre solution et la mienne vont probablement traverser les âges sans craquer.
Josué
1
Pour le votant inférieur, y at-il quelque chose d'illégitime dans cette soumission?
Rohan Jhunjhunwala
1
Il existe en fait une solution triviale pour cela (il ne s'agit pas de factoriser un équivalent en nombre RSA-440), malheureusement, elle nécessite ~ ~ 10 000 octets supplémentaires ...
SLuck49
1
@ SLuck49 pouvez-vous me commenter?
Rohan Jhunjhunwala
1
@ SLuck49 wow! Je viens de comprendre ce que tu regardais! J'ai presque perdu 500 points de réputation.
Rohan Jhunjhunwala
3

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

Betseg
la source
1
Fissuré. Pas la solution prévue car j'ai 1 octet de moins.
Riley
@Riley ajouter une nouvelle ligne à la fin et tout ira bien;)
Alfie Goodacre
2

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@"
DJMcMayhem
la source
Cracked C'était un casse
nmjcman101
2

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]

entrez la description de l'image ici

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.

Arnauld
la source
1
J'ai commencé à forcer cela brutalement en pensant que je pourrais avoir de la chance et vous avez fait en sorte que chacune des 4 valeurs de clé ait la même longueur (8 bits). Sauf que ce serait 16 bits chacun ... woops. La force brute ne va pas arriver, le temps d'une autre approche.
SLuck49
2

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}]
Addison Crump
la source
S'il vous plaît ne regardez pas l'historique d'édition, car il me restait un bogue dans mon code.
Addison Crump
Tu ne connais pas le mal. Je connais le mal.
Joshua
Il est à peine passé 03h00 pour moi, donc je vais ajouter une explication dans la matinée.
Addison Crump
1

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

TheLethalCoder
la source
1
Cracked
milk
1

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 .

Conor O'Brien
la source
La version sur Nexus était déjà à jour. J'ai aussi tiré sur v1.
Dennis
En vérifiant, cela fonctionne-t-il si l'entrée contient deux sauts de ligne consécutifs?
Martin Ender
@MartinEnder il le devrait. Cela dépend si l'entrée est connectée ou non. Quand piped il devrait lire tout stdin.
Conor O'Brien
@ Dennis merci! Je voulais vous demander dans le chat.
Conor O'Brien
Cracked
James Holderness
1

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]]]]&
bruissement
la source
> Votre soumission sera alors votre code source avec tous les espaces supprimés
Kritixi Lithos
@KritixiLithos Il est supprimé
swish
Qu'en est-il des espaces avant la deuxième ligne et de la nouvelle ligne entre la première et la deuxième ligne?
Kritixi Lithos
Eh bien, vous avez raison, c'est juste pour la lisibilité ...
swish
Je pense que vous pouvez poster la solution maintenant.
CalculatriceFeline
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.

Ephphatha
la source
0

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;}
Josué
la source
Lien vers interprète?
Addison Crump
@VoteToClose: apt-get install tcc l'a fait pour moi.
Joshua
0

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

Rohan Jhunjhunwala
la source