Dada una cadena como entrada, genera una cantidad de caracteres de espacio en blanco (0x0A y 0x20) igual a la longitud de la cadena.

Por ejemplo, dada la cadena, Hello, World!su código necesitaría generar exactamente 13 caracteres de espacio en blanco y nada más. Estos pueden ser cualquier combinación de espacios y líneas nuevas.

Su código no debe generar líneas o espacios finales adicionales.

Casos de prueba:

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

Tanteo:

Este es el código de golf, ¡ por lo que gana menos bytes!

Espacio en blanco , 311 150 77 68 65 46 41 38 bytes

^{-3 bytes gracias a Kevin Cruijssen
-27 bytes gracias a Ephphatha}

Pruébalo en línea!

Un formato visible

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

Explicación (s = espacio, t = tabulación, n = nueva línea)

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

ç

Pruébalo en línea!

Haskell , 7 bytes

(>>" ")

Pruébalo en línea! Uso: (>>" ") "Hello, world!".

Dadas dos listas (y las cadenas son listas de caracteres en Haskell), el >>operador repetirá la segunda lista tantas veces como la primera lista tenga elementos. Establecer " "como segundo argumento significa que concatenamos tantos espacios como la cadena de entrada es larga.

Alternativa (mismo recuento de bytes):

(' '<$)

Pruébalo en línea! Uso: (' '<$) "Hello, world!".

Dado un valor y una lista, el <$operador reemplaza cada valor de la lista con el valor dado. Por lo tanto, 5 <$ "abc"da como resultado [5,5,5], y ' ' <$ "abc"en " ".

La función se puede escribir de manera equivalente (<$)' ', en caso de que desee encontrar algunas criaturas marinas más en mi código.

brainfuck , 18 bytes

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

Pruébalo en línea!

Imprime una nueva línea para cada byte de entrada. Imprimir espacios en su lugar agregaría 4 bytes.

Python, 19 bytes

lambda s:' '*len(s)

Retina, 3 4 bytes

S\`.

La versión anterior no funciona porque Retina imprime un avance de línea final.

.
 

(La segunda línea contiene un espacio).

sed , 7 bytes

s/./ /g

Pruébalo en línea!

Brainfuck, 16 bytes

Imprime nuevas líneas.

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

C #, 28 24 bytes

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

Versión antigua que usa el stringconstructor para 28 bytes:

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

Retina , 5 bytes

\`.
¶

Pruébalo en línea! Cambia todo a nuevas líneas. El \`suprime el salto de línea extra Retina haría normalmente de salida.

Mathematica, 21 bytes

StringReplace[_->" "]

JavaScript ES6, 22 bytes

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

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

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

C, 31 bytes

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

PHP, 28 bytes

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

Pruébalo en línea!

PHP, 29 bytes

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

Pruébalo en línea!

Excel VBA, ₁₇ 15 bytes

Función de ventana inmediata VBE anónima que toma la entrada de la celda [A1]y genera espacios de longitud de la entrada a la ventana inmediata VBE

?Spc([Len(A1)])

05AB1E , 3 bytes

vð?

Pruébalo en línea!

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

Otras soluciones de 3 bytes (Gracias Urna de pulpo mágico y Kevin Cruijssen por la mayoría de estos)

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)

Octava, 14 bytes

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

CJam , 4 bytes

q,S*

Pruébalo en línea!

Explicación

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

C, 45 bytes

Usando main. Compila con gcc, ignora las advertencias.

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

Uso:

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

JavaScript (ES6), 23 bytes

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

Excel, 18 bytes

=REPT(" ",LEN(A1))

Bastante aburrido y un byte más largo que la respuesta de VBA .

> <> , 7 bytes

i0(?;ao

El programa es un bucle.

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 bytes

Ò 

Pruébalo en línea!

Tenga en cuenta el espacio final!

Hexagonía , 12 11 bytes

-1 byte gracias a Martin Ender

,<.;.M@.>~8

Pruébalo en línea!

Aquí está el hex expandido:

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

Mientras hay entrada, este código se ejecuta:

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

Cuando se alcanza EOF:

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

Perl 5 , 7 bytes

-1 byte gracias a @Xcali

6 bytes de código + -pbandera.

y// /c

Pruébalo en línea!

Muy sencillo: reemplaza a cada personaje con un espacio.

Python 2, 25 bytes

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

-2 bytes gracias a Loovjo
-2 bytes en el código inválido gracias a totalmente humano: p
-3 bytes

PHP, 36 bytes

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

Pruébalo en línea!

Produce nuevas líneas porque los espacios son demasiado convencionales

Cubix , 6 bytes

Wahoo un 6 byter!

wi?@oS

Cubified

  w
i ? @ o
  S

• i obtiene entrada
• ? probar la parte superior de la pila
  • si es negativo (EOI) redirige al wcambio de carril que se @detiene
  • si 0 (nulo) se detiene, esto no debería ser golpeado
  • si hay Sowespacio de empuje positivo para la pila, salida y cambie de carril ai

Pruébalo en línea!

C, 32 bytes

Intenta modificar personajes en línea en espacios

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

C, 37 bytes

Pruebe en línea rellenando el extremo izquierdo de la cadena con su longitud

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

APL (Dyalog) 13.2, 1 byte

Imprime solo espacios.

∊ prototipo (los números se convierten en ceros, los caracteres se convierten en espacios)

Pruébalo en línea!