Data una stringa come input, emette un numero di caratteri di spazi bianchi (0x0A e 0x20) pari alla lunghezza della stringa.

Ad esempio, data la stringa Hello, World!il codice dovrebbe generare esattamente 13 caratteri di spazi bianchi e nient'altro. Questi possono essere qualsiasi mix di spazi e newline.

Il codice non dovrebbe generare ulteriori righe o righe finali.

Casi test:

     Input      -> Amount of whitespace to output
"Hello, World!" -> 13
"Hi"            -> 2
"   Don't
Forget about
Existing
Whitespace!   " -> 45
""              -> 0
"             " -> 13
"
"               -> 1

punteggio:

Si tratta di code-golf quindi vince il minor numero di byte!

Spazio bianco , 311 150 77 68 65 46 41 38 byte

^{-3 byte grazie a Kevin Cruijssen
-27 byte grazie a Ephphatha}

Provalo online!

Un formato visibile

'\n  \n   \t \t \n \n  \n \t\n\t \t\t\t\n\t  \n\t\n  \n \n\n'

Spiegazione (s = spazio, t = tab, n = nuova riga)

nssn     # label(NULL) - loop start
ssststsn # push 10 in the stack -> [10]
sns      # duplicate the top of the stack -> [10, 10]
sns      # duplicate the top of the stack -> [10, 10, 10]
tnts     # read a single char from input, pop the stack and store at that address -> [10, 10] [10:<char that was read>]
ttt      # pop the stack and put the value at that adress on stack -> [10,<char>] [10:<char>]
ntssn    # jump to label(0) - since label(0) is not defined, the interpreter jumps to the end of the program - if the top of the stack (char) is 0 -> [10] [10:<char>]
tnss     # pop the top of the stack and print as ascii -> [] [10:<char>]
nsnn     # go back to the label(NULL)

Japt , 1 byte

ç

Provalo online!

Haskell , 7 byte

(>>" ")

Provalo online! Uso: (>>" ") "Hello, world!".

Dati due elenchi (e le stringhe sono elenchi di caratteri in Haskell) l' >>operatore ripeterà il secondo elenco tutte le volte che il primo elenco contiene elementi. L'impostazione " "come secondo argomento significa che concateniamo tanti spazi quanti la stringa di input è lunga.

Alternativa (stesso conteggio byte):

(' '<$)

Provalo online! Uso: (' '<$) "Hello, world!".

Dato un valore e un elenco, l' <$operatore sostituisce ogni valore nell'elenco con il valore dato. Quindi 5 <$ "abc"risulta in [5,5,5]e ' ' <$ "abc"in " ".

La funzione può essere equivalentemente scritta come (<$)' ', nel caso in cui volessi trovare altre creature marine nel mio codice.

Brainfuck , 18 byte

++++++++++>,[<.>,]

Provalo online!

Stampa una nuova riga per ogni byte di input. Gli spazi di stampa invece aggiungerebbero 4 byte.

Python, 19 byte

lambda s:' '*len(s)

Retina, 3 4 byte

S\`.

Vecchia versione, non funziona perché Retina stampa un feed riga finale.

.
 

(La seconda riga contiene uno spazio).

sed , 7 byte

s/./ /g

Provalo online!

Brainfuck, 16 byte

Stampa newline.

,[>++++++++++.,]

C #, 28 24 byte

s=>"".PadLeft(s.Length);

Vecchia versione che utilizza il stringcostruttore per 28 byte:

s=>new string(' ',s.Length);

Retina , 5 byte

\`.
¶

Provalo online! Cambia tutto in newline. Il \`sopprime il ritorno a capo in più Retina normalmente uscita.

Mathematica, 21 byte

StringReplace[_->" "]

JavaScript ES6, 22 byte

a=>a.replace(/./g," ")

f=a=>a.replace(/./g," ");

var test = f("Hello, World!");
console.log(test, test.length);

C, 31 byte

f(char*c){puts(""),*c++&&f(c);}

PHP, 28 byte

for(;a&$argn[$i++];)echo" ";

Provalo online!

PHP, 29 byte

<?=str_pad('',strlen($argn));

Provalo online!

Excel VBA, ₁₇ 15 byte

Funzione di finestra immediata VBE anonima che prende l'input dalla cella [A1]e genera spazi di lunghezza dell'input nella finestra immediata di VBE

?Spc([Len(A1)])

05AB1E , 3 byte

vð?

Provalo online!

v   # For each character...
 ð? #    Output a space without a newline

Altre soluzioni a 3 byte (grazie a Magic Octopus Urn e Kevin Cruijssen per la maggior parte di questi)

v¶? # For each character print a newline (without adding a newline)
võ, # For each character print the empty string with a newline
gð× # Get the length, concatenate that many copies of space
g¶× # Get the length, concatenate that many copies of newline
Sð: # Split, push a space, replace each char in input with a space
ðs∍ # Push ' ', swap, make the string of spaces as long as the input was
võJ # For each char, push a space and ''.join(stack)
v¶J # For each char, push a newline and ''.join(stack)
€ðJ # For each char, push a space. Then ''.join(stack)
ۦJ # For each char, push a newline. Then ''.join(stack)

Ottava, 14 byte

@(a)["" 0*a+32]

CJam , 4 byte

q,S*

Provalo online!

Spiegazione

q     e# Read input
 ,    e# Length
  S*  e# Repeat space that many times

C, 45 byte

Utilizzando principale. Compila con gcc, ignora gli avvisi.

main(c,v)char**v;{while(*(v[1]++))puts("");}

Uso:

$./a.out "Hello, World!"

JavaScript (ES6), 23 byte

s=>" ".repeat(s.length)

Excel, 18 byte

=REPT(" ",LEN(A1))

Abbastanza noioso e un byte più lungo della risposta VBA .

> <> , 7 byte

i0(?;ao

Il programma è un ciclo

i         //Push a character from the input onto the stack
 0        //Add a 0 to the stack
  (       //Pop the top two values of the stack, and push a 1 if the second is less than the first (In this case, the input has all been read), else push a 0
   ?      //Pop the top of the stack. If the value is a 0, skip the next instruction
    ;     // Terminate the program
     a    // Add a newline to the stack
      o   // Pop the top character of the stack and print it

V , 2 byte

Ò 

Provalo online!

Nota lo spazio finale!

Esagonia , 12 11 byte

-1 byte grazie a Martin Ender

,<.;.M@.>~8

Provalo online!

Ecco l'esagono espanso:

  , < . 
 ; . M @
. > ~ 8 .
 . . . .
  . . .

Mentre c'è input, questo codice viene eseguito:

,        # Get input
 <       # Turn right (SE) if we didn't get EOF
  M8     # Set the memory edge to 778 which is 10 (mod 256)
    ;    # Print as a character (newline)
     >   # Redirect East
      ~  # Multiply by -1. This makes the pointer go to the top when it runs off the edge
       8 # Effectively a no-op.

Quando viene raggiunto l'EOF:

,    # Get input
 <   # Turn left (NE)
  8  # Effectively a no-op
   @ # End program

Perl 5 , 7 byte

-1 byte grazie a @Xcali

6 byte di codice + -pflag.

y// /c

Provalo online!

Abbastanza semplice: sostituisce ogni personaggio con uno spazio.

Python 2, 25 byte

exec'print;'*len(input())

-2 byte grazie a Loovjo
-2 byte nel codice non valido grazie a totalhuman: p
-3 byte

PHP, 36 byte

<?=str_repeat('
',strlen($argv[1]));

Provalo online!

Emette nuove righe perché gli spazi sono troppo mainstream

Cubix , 6 byte

Wahoo a 6 byter!

wi?@oS

Cubified

  w
i ? @ o
  S

• i ottiene input
• ? test in cima allo stack
  • se il reindirizzamento negativo (EOI) sul wcambio di corsia si @arresta
  • se 0 (null) ferma questo non dovrebbe essere colpito
  • se lo Sowspazio positivo spinge verso lo stack, emette e cambia corsiai

Provalo online!

C, 32 byte

Prova a modificare online i caratteri in spazi

f(char*t){(*t=*t?32:0)&&f(t+1);}

C, 37 byte

Prova Online Riempimento a sinistra della fine della stringa con la sua lunghezza

f(char*t){printf("%*c",strlen(t),0);}

APL (Dyalog) 13.2, 1 byte

Stampa solo spazi.

∊ prototipo (i numeri diventano zeri, i personaggi diventano spazi)

Provalo online!