Questo fa parte della sfida di Cops and Robbers. Vai qui per la parte degli sbirri.

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 dei ladri

La risposta di un poliziotto può essere decifrata trasformandola in un programma o una funzione validi (nella lingua scelta), che svolge il compito di rimuovere gli spazi bianchi da una stringa di input, inserendo gli spazi bianchi nel codice. Ad esempio se hai ricevuto il seguente input:

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

Il programma dovrebbe essere emesso

Hello,World!

Dopo aver inserito gli spazi bianchi, il conteggio dei byte della soluzione non deve superare il conteggio dei byte indicato nella risposta del poliziotto. Non devi trovare la stessa identica soluzione del poliziotto previsto, a condizione che il tuo sia valido per i vincoli di cui sopra.

Se lo gestisci, pubblica una risposta con la soluzione, collegandoti alla risposta del poliziotto e lascia un commento sulla risposta del poliziotto che rimanda alla tua.

Vince il ladro che incrina il maggior numero di poliziotti. I legami sono spezzati dalla somma delle dimensioni delle risposte del poliziotto incrinato (a favore del ladro che rompe gli invii più lunghi).

Ogni risposta del poliziotto può essere decifrata una sola volta e, naturalmente, non ti è permesso di decifrare la tua risposta. Se la risposta del poliziotto risulta non valida prima o dopo il crack, non viene conteggiata per il punteggio del ladro.

Haskell, 100 byte, di 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 byte, di DanTheMan

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

Davvero divertente da allenare.

Provalo su> <> lingua

JavaScript ES6, 199 byte di 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``

Ho capito che la divisione "SecretCode"significava che stavo cercando 11 numeri che riassumevano (presumevo) 33. Questo è un problema a stelle e barre in cui il numero di spazi sono le stelle e le lettere dentro "SecretCode"erano le barre. Ho fatto i calcoli per vedere quante combinazioni ci fossero da provare (1.917.334.783 combinazioni) e ho deciso di forzare bruscamente la forza, impiegando tutto il giorno.

Probabilmente c'è un modo più intelligente di farlo, ad esempio notando che kdeve essere 33e 66per l'indice 10 e 21 rispettivamente, ma sono pigro.

C, 475 byte di 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}

Potrei iniziare ad usare alcune di queste definizioni :)

Dopo il pre-processore il codice è simile al seguente:

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

Rubino, 86 byte + 1 bandiera = 87 dell'istocratico

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

Questo è stato davvero divertente, ogni carattere nella stringa passato evalviene sostituito con il codice carattere ( ord) XORed ^(...)rispetto al numero di spazi rimanenti nella stringa. Il codice risultante è:

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

RprogN, di Ataco

Questo sembra fare il trucco

' ' ` R
"
" ` R

V, 37 byte, di DJMcMayhem

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

Unprintables:

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

TryItOnline

Il üveramente mi ha gettato per un ciclo, ho tenuto in attesa sia esso e îdi essere comandi.

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 si traduce in :%s/ \|\n//gin vim, che rimuove globalmente tutto lo spazio bianco. Il Ícomando è sul wiki, üe îsono |e nrispettivamente con il loro bit alto impostato

C, 140 byte da 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();}}

(Spero anche di farlo bene.)

MATL, 22 byte di Luis Mendo

Anche se non posso essere sicuro del perché, questo sembra funzionare

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

Dovrò vedere se riesco a capire cosa sta facendo. Ho pensato che i commenti dovevano avere feed di riga dopo di loro e quindi era solo una questione di ottenere gli spazi nei punti corretti.

MATL, 22 21 byte di Luis Mendo.

Alla fine ... MickyT l'ha risolto mentre stavo scrivendo una spiegazione, quindi la sua risposta è quella "valida". L'ho pubblicato comunque, in conformità con questo meta post .

Me Ysono inutili e vengono commentati. È sufficiente aggiungere 4 caratteri spazi bianchi, non 5.

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

Ciò equivale al più compatto :

t' @ *'dm7dw(

Spiegazione parziale:

         % 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 byte di ninjalj

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

Provalo online!

Questo è stato molto divertente. Ho dedotto che poiché ci sono pochi comandi che cambiano direzione e no ^<[]?xo simili, deve usare il wrapping. Ho quindi scritto uno script in Python per aiutare a ottenere la spaziatura giusta per quella j.

Il codice funziona prendendo input ( ~) e duplicandolo due volte (:: ). Quindi sottrae 10 ( ':'0o ord(':') - ord('0')) e 32 ( '[';o ord('[') - ord(';')). Quindi, il secondo risultato viene logicamente negato (1 se era spazio, 0 altrimenti) e viene premuto un 8.

Ora arriva la parte che doveva capire cosa saltare. Il 1+!è saltato continuando alla riga successiva. #salta il @. Il risultato logicamente negato (0 o 1) viene moltiplicato per 8 e viene aggiunto 1.

Il codice quindi salta quel numero di spazi (ovvero 1 o 9) più uno in più mentre l'IP si sposta. Se il personaggio non era uno spazio, finisce in! . Il codice carattere meno 10 è logicamente negato (1 se era newline, 0 altrimenti). jquindi non salta nulla e ,viene chiamato print ( ) e il ciclo riprende avvolgendosi verticalmente.

Se il personaggio era uno spazio, la linea di fondo si sposta nuovamente 32, 22come fondo della pila. I primi jsalti 705 spazi. Quindi la linea scorre una terza volta. Se sullo stack sono rimasti più di due 10 (il codice lascia solo quelli), il primo jsalta 100 spazi e il ciclo si ripete. Altrimenti, il primoj salta a !, uno zero viene negato, il secondo jsalta sulla stampa e il programma continua.

Sono riuscito a golf fino a 59 byte.

C # 6, 201 byte, dal latte

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

demo di repl.it

trueJoinnon è definito, quindi string.Concat()rimane solo .
plo è "\n". p[0]^32^10è spazio. Sarebbe stato (un po ') più difficile se fosse p[0]^42o altre costanti simili.

reticolare, 43 byte, di Conor O'Brien

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

Provalo online!

Questo è stato più difficile per me di quanto avrebbe dovuto essere perché ero troppo stupido per trovare la documentazione e alla fine ho dovuto indovinare come funzionavano alcuni comandi. Quindi alcune di queste spiegazioni potrebbero non essere del tutto esatte, ma questa era la mia comprensione di base del codice.

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 byte di 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 stringa alla fine della riga 1 è " \n"(spazio + nuova riga).

/*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 byte di Kritixi Lithos

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

Spiegazione

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