Cela fait partie d'un défi Cops and Robbers. Allez ici pour la partie des flics.

Aux fins de ce défi, nous allons définir les espaces comme seulement linefeeds (0x0A) et des espaces (0x20). Notez que la plupart des langues et des variantes d'expression régulière considèrent également de nombreux autres caractères comme des espaces, à la fois à l'intérieur et à 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 voleurs

La réponse d'un flic peut être craquée en la transformant en un programme ou une fonction valide (dans la langue choisie), qui effectue la tâche de suppression des espaces blancs d'une chaîne d'entrée, en insérant des espaces blancs dans le code. Par exemple, si vous avez reçu l'entrée suivante:

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

Le programme devrait sortir

Hello,World!

Après avoir inséré un espace, le nombre d'octets de la solution ne doit pas dépasser le nombre d'octets indiqué dans la réponse du policier. Vous n'avez pas à trouver exactement la même solution que le policier prévu, tant que la vôtre est valide par les contraintes ci-dessus.

Si vous gérez cela, postez une réponse avec la solution, en vous liant à la réponse du flic, et laissez un commentaire sur la réponse du flic en vous reliant à la vôtre.

Le voleur qui déchire le plus de réponses de flic gagne. Les liens sont rompus par la somme des tailles des réponses des flics fêlés (en faveur du voleur qui déchire les soumissions plus longues).

Chaque réponse de flic ne peut être crackée qu'une seule fois, et bien sûr, vous n'êtes pas autorisé à cracker votre propre réponse. Si la réponse du policier s'avère invalide avant ou après avoir été piratée, elle n'est pas prise en compte dans le score du voleur.

Haskell, 100 octets, par Laikoni

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

> <>, 40 octets, par DanTheMan

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

Vraiment amusant à travailler.

Essayez-le sur> <> langue

JavaScript ES6, 199 octets par Arnauld

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

J'ai réalisé que le fractionnement "SecretCode"signifiait que je cherchais 11 nombres qui se résumaient à (je suppose) 33. C'est un problème d' étoiles et de barres où le nombre d'espaces sont les étoiles et les lettres entre "SecretCode"les barres. J'ai fait le calcul pour voir combien de combinaisons il y avait à essayer (1 917 334 783 combinaisons) et j'ai décidé de simplement le forcer brutalement, cela a pris toute la journée.

Il y a probablement une façon plus intelligente de s'y prendre, par exemple en remarquant que cela kdoit être 33et 66pour les index 10 et 21 respectivement, mais je suis paresseux.

C, 475 octets par Rexroni

#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
#define gpml ml h
#define abo
#define ml d m p
#define jg d o abo
#define lb abo d
#define gf h abo c
#define jgm b e n
#define pml f g
#define gpm lb
int main(){a jg a jgm l jg i g pml k m l gpml h j g d!=' '&&gpm!='\n'gf g p m l gpml o}

Je pourrais commencer à utiliser certaines de ces définitions :)

Après le pré-processeur, le code ressemble à ceci:

int main(){
    char stdin;
    char *stdout = &stdin;
    while(read(0, &stdin, 1))
        if(stdin !='' && stdin!='\n')
            write(1, &stdin, 1);
}   

Ruby, 86 octets + 1 drapeau = 87 par histocrate

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

C'était vraiment amusant, chaque caractère de la chaîne passée evalest remplacé par le code de caractère ( ord) XORed par ^(...)rapport au nombre d'espaces restants dans la chaîne. Le code résultant est:

$_.tr!(''<<32<<10,'')

RprogN, par Ataco

Cela semble faire l'affaire

' ' ` R
"
" ` R

V, 37 octets, par DJMcMayhem

O     VrS200@"kIi|D@"A üî|D@"

Non imprimables:

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

TryItOnline

Le üm'a vraiment jeté pour une boucle, je me attendais à la fois et îd'être des commandes.

O                 # Insert 5 spaces above this line
Vr<C-a>           # Change them all to <C-a>
S200<esc>         # Replace the line with 200
@"                # Play back the 5 <C-a>'s, 200 -> 205
k                 # ????
Ii<C-v><C-v><esc> # insert "i<C-v>" so our line is now "i<C-v>205"
|D@"<esc>         # Delete the line and then run it, which inserts "Í" (ASCII 205)
A üî<esc>         # Append " üî" so our line is "Í üî"
|D@"              # Delete the line and run it

Í üîin V se traduit par :%s/ \|\n//gin vim, qui supprime globalement tous les espaces. La Ícommande est sur le wiki, et les üet îsont |et nrespectivement avec leur ensemble de bits élevé

C, 140 octets par betseg

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

(J'espère aussi que je fais ça correctement.)

MATL, 22 octets par Luis Mendo

Bien que je ne sache pas pourquoi, cela semble fonctionner

t' @ * 'dm1e5%M
dw%Y
(

Je vais devoir voir si je peux comprendre ce qu'il fait. J'ai pensé que les commentaires devaient avoir des sauts de ligne après eux et ensuite il s'agissait simplement de placer les espaces aux bons endroits.

MATL, 22 21 octets par Luis Mendo.

Enfin ... MickyT l'a craqué pendant que j'écrivais une explication, donc sa réponse est "valable". J'ai quand même posté cela, conformément à ce meta post .

Met Ysont inutiles et sont commentés. Il suffit d'ajouter 4 espaces, pas 5.

t' @ *'dm1e5%M
dw%Y
(

C'est l'équivalent du plus compact :

t' @ *'dm7dw(

Explication partielle:

         % Implicit input
t        % Duplicate input
' @ *'   % String with ASCII-values [32   64   32   42]
d        % diff, giving [32  -32   10], 32 is space, 10 is newline
m        % ismember, checking if the character is 32 or 10
1e5      % 10000, but could just as well be 7
d        % Taking the diff of the scalar 1e5, returning an empty matrix []
w        % Swap stack in order to use ( below
(        % Equivalent to x(y)=[], where x is the input string, and y is the logical
         % vector found using ismember (m)
         % Implicit output

Befunge-98, 65 octets par ninjalj

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

Essayez-le en ligne!

C'était très amusant. J'ai déduit que puisqu'il y a peu de commandes qui changent de direction et aucune^<[]?x ou similaire, il doit utiliser un habillage. J'ai ensuite écrit un script Python pour aider à obtenir l'espacement correct pour les j.

Le code fonctionne en prenant input ( ~) et en le dupliquant deux fois ( ::). Il soustrait ensuite 10 ( ':'0ou ord(':') - ord('0')) et 32 ​​('['; ou ord('[') - ord(';')). Ensuite, le deuxième résultat est logiquement annulé (1 s'il s'agissait d'espace, 0 sinon) et un 8 est poussé.

Vient maintenant la partie qui avait besoin de savoir quoi ignorer. Le 1+!est ignoré en passant à la ligne suivante.#saute le @. Le résultat nié logiquement (0 ou 1) est multiplié par le 8 et 1 est ajouté.

Le code saute alors autant d'espaces (c'est-à-dire 1 ou 9) plus un espace supplémentaire au fur et à mesure que l'IP se déplace. Si le personnage n'était pas un espace, il se retrouve au !. Le code de caractère moins 10 est logiquement annulé (1 si était un saut de ligne, 0 sinon).jpuis ne saute rien, et print ( ,) est appelé et la boucle reprend en encapsulant verticalement.

Si le personnage était un espace, la ligne du bas boucle à nouveau avec 32, 22le bas de la pile. Le premier jsaute 705 espaces. Ensuite, la ligne boucle une troisième fois. S'il reste plus de deux 10 sur la pile (le code ne laisse que ceux-ci), le premier jsaute 100 espaces et la boucle se répète. Sinon, le premier jsaute vers le !, un zéro est annulé, le second jsaute sur l'impression et le programme continue.

J'ai réussi à jouer au golf à 59 octets.

C # 6, 201 octets, par lait

using System.Linq;
_=>string./**/
#if trueJoin
(/*"*//*/""/**//*/"*/",
#else
Concat(//*/,
#endif
from m in" "let p=$@"{@" 
"[1]}"from i in(_.Replace(p,@""))where!new[]{p[0]^32^10}.Contains(i)select@i);

démo repl.it

trueJoinn'est pas défini, il ne string.Concat()reste donc que .
pest "\n". p[0]^32^10est l'espace. Cela aurait été (un peu) plus difficile s'il s'agissait de p[0]^42constantes similaires.

réticulaire, 43 octets, par Conor O'Brien

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

Essayez-le en ligne!

Cela a été plus difficile pour moi qu'il n'aurait dû l'être parce que j'étais trop stupide pour trouver la documentation et j'ai dû deviner comment certaines commandes fonctionnaient. Donc, certaines de ces explications peuvent ne pas être entièrement exactes, mais c'était ma compréhension de base du code.

I               Push all the input on to the stack as a string
 S              Convert it into a character array.
  B             Turns that array into individual characters on the stack.
   q            Reverse the stack so the first letter is on top.
    v           Move down... 
    /           ...and turn left.
E :d            Duplicate the value and test if equal to space.

       v?       If it is a space we move down until we wrap to the top.
       >$$      Drop the test result and the space.
          4j    Jump over the next 4 commands (having wrapped to the start).
    v           Bringing us back to the first down arrow, ready to test the next char.

     v$         If it wasn't a space, drop the test result and move down.
c+91d/          Turn left and push a newline (char 10) on to the stack.
       v?E      If equal, we go down, following the same path as with the space.

     /          If not equal, turn down.
   l$/          Then turn left, drop the test result, and push the stack size.
;!?             If zero (the stack is empty) we terminate.
        o$      Otherwise wrap around, drop the stack size, and output the char. 
     /          Then turn down wrapping around to the top of the program.
    v<          Then turn left and down to start the process from the beginning again.

C #, 159 octets par LethalCoder

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

repl.it

La chaîne à la fin de la ligne 1 est " \n"(espace + nouvelle ligne).

/*Func<string, string> Lambda =*/ s =>
    string.Join("",                                                           // No-op
    string.Join("",                                                           // Join (without whitespace)
        s.Split(@" \n".Replace(new string((char)0x0D,1),"").ToCharArray())    // Split on whitespace
    ).Select(c=>c+""!=""?c+"":"").ToArray());                                 // No-op

Minkolang v0.15, 88 octets par Kritixi Lithos

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

Explication

                               # Layer 1
$o                             # input chars onto stack
  I                            # stack length pushed to stack
   [                    ]      # loop popped TOS times (length of string)
    dd                         # duplicate, duplicate
      " "                      # push space to stack
         =                     # equality check
          $r                   # swap
            '10'               # number 10 to stack (LF char)
                =              # equality
                 1J            # or
                   ,           # not
                    ?          # if true jump next
                               # drop to layer 2
                      1R       # rotates the stack 1 time
                         r     # reverse the stack
                          $O   # output the stack
                             . # stop
$$$                            # Layer 2
                     >         # shift right and then drop to layer 3
$$$                            # Layer 3
                      >x       # shift right, pop char off stack and drop to Layer 1 (end loop)