Algunos esolangs bidimensionales, como Forked , y algunos no esolangs, como Python , a veces pueden requerir espacios antes de las líneas de código. Esto no es muy golfoso. _{^{Además, soy flojo y escribo un lenguaje 2D que necesita muchos espacios antes del código.}} Su tarea es escribir una herramienta que haga que estos idiomas sean más golfistas.

Por supuesto, esto no será perfecto; no se puede usar, por ejemplo, cuando un número es el primer carácter en una línea de origen. Sin embargo, generalmente será útil.

Desafío

Escribirás un programa o función que ...

• ... toma un argumento, un nombre de archivo o una cadena, o ...
• ... lee de la entrada estándar.

Su programa actuará como cat, excepto:

• Si el primer carácter en cualquier línea es un número, su código imprimirá x espacios, donde x es ese número.
• De lo contrario, simplemente se imprimirá.
• Como lo hará cualquier otro personaje en la entrada.

Casos de prueba

Entrada:

foo bar foo bar
1foo bar foo bar foo bar
2foo bar foo bar foo bar foo bar

Salida:

foo bar foo bar
 foo bar foo bar foo bar
  foo bar foo bar foo bar foo bar

Entrada:

--------v
8|
8|
80
8,
7&

Salida:

--------v
        |
        |
        0
        ,
       &

Entrada:

foo bar
bar foo
foo bar

Salida:

foo bar
bar foo
foo bar

Entrada:

0123456789
1234567890
2345678901
3456789012
4567890123

Salida:

123456789
 234567890
  345678901
   456789012
    567890123

Reglas

• La salida debe ser exactamente como entrada, excepto para las líneas donde el primer carácter es un número.
• Su programa no puede agregar / anteponer nada al archivo, excepto una nueva línea final si lo desea.
• Su programa puede no hacer suposiciones sobre la entrada. Puede contener líneas vacías, sin números, caracteres Unicode, lo que sea.
• Si un número con más de un dígito comienza una línea (por ejemplo 523abcdefg), solo el primer dígito (en el ejemplo, 5) debe convertirse en espacios.

Ganador

El código más corto en cada idioma gana. ¡Diviértete y buena suerte!

Retina , 9 bytes

m`^\d
$* 

Pruébalo en línea! Nota: espacio final en la última línea.

Cúbicamente , 69 bytes

R1B1R3B1~(+50<7?6{+54>7?6{-002+7~?6{(@5*1-1/1)6}}}(-6>7?6&@7+70-4~)6)

Pruébalo en línea!

Explicación:

Primero hacemos esta inicialización:

R1B1R3B1

Para configurar este cubo:

   533
   004
   000
411223455441
311222331440
311222331440
   555
   555
   200

Lo más importante de este cubo es que las 5sumas de la cara son 32, que es el valor requerido para imprimir espacios. Casualmente, también resulta ser bastante corto para todos los demás cálculos. Después de eso se hace:

~( . . . )                                    Takes the first input, then loops indefinitely

  +50<7?6{+54>7?6{-002+7~?6{(@5*1-1/1)6}}}    Handle leading digit:
  +50<7?6{                               }    If input is greater than 47 ('0' is 48)
          +54>7?6{                      }     And input is less than 58 ('9' is 57)
                                              Then input is a digit
                  -002+7                      Set notepad equal to value of input digit
                        ~                     Take next input (only convenient place for it)
                         ?6{           }      If the notepad isn't 0
                            (        )6       While the notepad isn't 0:
                             @5                 Print a space
                               *1-1/1           Decrement the notepad by one
                                              Leading digit handled

     (-6>7?6&@7+70-4~)6                       Handle rest of line:
     (               )6                       While the notepad isn't 0:
      -6>7?6&                                   Exit if End of Input
             @7                                 Print the next character
               +70-4                            Set notepad to 0 if it was a newline
                    ~                           Take the next character

Casco , 15 13 bytes

-2 bytes gracias a @Zgarb

mΓo+?oR' i;±¶

Pruébalo en línea!

Utiliza la misma técnica que @Jonathan Allan

Explicación

             ¶  -- split input into a list of lines
m               -- apply the following function to each line
 Γ              --   deconstruct the string into a head and a tail
  o+            --   prepend to the tail of the string ...
    ?      ±    --     if the head is a digit (n)
     oR' i      --       the string of n spaces
                --     else
          ;     --       the head of the string
                -- implicitly print list of strings line-by-line

JavaScript (ES8), 38 37 bytes

a=>a.replace(/^\d/gm,a=>''.padEnd(a))

No creo que se pueda mejorar mucho más.
Guardado 1 byte gracias a Shaggy : utilice las funciones de ES8.

Python 2 , 98 74 67 65 bytes

-24 bytes gracias a Jonathan Allan. -7 bytes gracias al Sr. Xcoder.

for i in open('f'):print' '*int(i[0])+i[1:]if'/'<i[:1]<':'else i,

Pruébalo en línea!

Toma entrada en el archivo nombrado f.

rubí , 24 21 + 1 = 25 22 bytes

Utiliza el -p bandera. -3 bytes de GB.

sub(/^\d/){"%#$&s"%p}

Pruébalo en línea!

05AB1E , 10 bytes

v0y¬dićú},

Pruébalo en línea!

Python 3 , 95 bytes

lambda y:'\n'.join(re.sub('^\d',lambda x:' '*int(x.group()),z)for z in y.split('\n'))
import re

Pruébalo en línea!

-4 bytes al robar la idea regex de ThePirateBay

Jalea , 19 bytes

V⁶ẋ
Ḣǹe?ØD;
ỴÇ€Yḟ0

Un enlace monádico que toma y devuelve listas de caracteres, o un programa completo que imprime el resultado.

Pruébalo en línea!

¿Cómo?

V⁶ẋ - Link 1, make spaces: character (a digit)
V   - evaluate as Jelly code (get the number the character represents)
 ⁶  - a space character
  ẋ - repeat

Ḣǹe?ØD; - Link 2, process a line: list of characters
Ḣ        - head (get the first character and modify the line)
         -   Note: yields zero for empty lines
     ØD  - digit characters = "0123456789"
    ?    - if:
   e     - ...condition: exists in? (is the head a digit?)
 Ç       - ...then: call the last link as a monad (with the head as an argument)
  ¹      - ...else: identity (do nothing; yields the head)
       ; - concatenate with the beheaded line

ỴÇ€Yḟ0 - Main link: list of characters
Ỵ      - split at newlines
 Ç€    - call the last link (1) as a monad for €ach
   Y   - join with newlines
    ḟ0 - filter out any zeros (the results of empty lines)

Perl 5 , 13 + 1 (-p) = 14 bytes

s/^\d/$"x$&/e

Pruébalo en línea!

Haskell , 63 bytes

unlines.map g.lines
g(x:r)|x<';',x>'/'=(' '<$['1'..x])++r
g s=s

Pruébalo en línea! La primera línea es una función anónima que divide una cadena dada en líneas, aplica la función ga cada línea y une las líneas resultantes con nuevas líneas. En gella se verifica si el primer carácter xde una línea es un dígito. Si este es el caso, ['1'..x]produce una cadena con una longitud igual al valor del dígito xy ' '<$convierte la cadena en tantos espacios. Finalmente rse agrega el resto de la línea . Si xno es un dígito, estamos en la segunda ecuación g s=sy devolvemos la línea sin modificar.

Python 2 , 76 72 68 bytes

-4 bytes gracias a @ovs !

@DeadPossum sugirió cambiar a Python 2, que también ahorró 4 bytes.

Solo pensé que es bueno tener un programa completo competitivo en Python 2 que no verifique explícitamente si el primer carácter es un dígito. Esto lee la entrada desde un archivo, f.

for i in open('f'):
 try:r=int(i[0])*" "+i[1:]
 except:r=i
 print r,

Pruébalo en línea! (cortesía de @ovs )

Java 8 , 105 99 97 93 bytes

Ahorré algunos bytes más gracias a la sugerencia de Nevay,

s->{int i=s.charAt(0);if(i>47&i<58)s=s.substring(1);while(i-->48)s=" "+s;System.out.print(s);}

R , 138 128 bytes

-9 bytes gracias a CriminallyVulgar

n=readLines();for(d in grep("^[0-9]",n))n[d]=gsub('^.?',paste0(rep(' ',eval(substr(n[d],1,1))),collapse=''),n[d]);cat(n,sep='
')

Esto es bastante malo, pero ahora es un poco mejor ... R es, una vez más, terrible en las cuerdas.

Pruébalo en línea!

Japt (v2.0a0), 11 10 bytes

¿Japt venció a Jelly y 05AB1E? Eso no parece correcto!

r/^\d/m_°ç

Pruébalo

Explicación

Entrada implícita de cadena U

r/^\d/m

Use Regex replace ( r) todas las apariciones de un dígito al comienzo de una línea ( mes la bandera multilínea; la gbandera está habilitada de forma predeterminada en Japt).

_

Pase cada partido a través de una función, donde Zestá el elemento actual.

°

El operador de incremento de postfix ( ++). Esto se convierte Zen un entero sin aumentarlo para la siguiente operación.

ç

Repetir un espacio de caracteres Zveces.

Salida implícita de la cadena resultante.

Jalea , 19 bytes

Ḣ⁶ẋ;µ¹µḣ1ẇØDµ?
ỴÇ€Y

Pruébalo en línea!

-5 bytes en total gracias a los comentarios de Jonathan Allan y al mirar su publicación

Explicación

Ḣ⁶ẋ;µ¹µḣ1ẇØDµ?  Main link
             ?  Ternary if
                if:
       ḣ1       the first 1 element(s) (`Head` would modify the list which is not wanted)
         ẇ      is a sublist of (essentially "is an element of")
          ØD    "0123456789"
                then:
  ẋ             repeat
 ⁶              ' '
Ḣ               n times where n is the first character of the line (head)
   ;            concatenate the "beheaded" string (wording choice credited to Jonathan Allan)
                else:
     ¹          Identity (do nothing)
    µ µ     µ   Link separators
ỴÇ€Y            Executed Link
Ỵ               Split by newlines
  €             For each element,
 Ç              call the last link on it
   Y            Join by newlines

Pyth ,  16  15 bytes

jm.x+*;shdtdd.z

Pruébalo en línea!

Explicación

jm.x + *; shdtdd.z: programa completo que funciona leyendo todo desde STDIN.

             .z: lea todo STDIN y divídalo por avances de línea.
 m - Mapa con una variable d.
  .x - Prueba:
     *; shd: para convertir el primer carácter en un entero y multiplicarlo por un espacio.
    + td - Y agrega todo excepto el primer personaje
            d - Si lo anterior falla, simplemente agregue la cadena completa.
j - Únete por nuevas líneas.

Tomemos un ejemplo que debería ser más fácil de procesar. Digamos que nuestra entrada es:

foo bar foo bar
1foo bar foo bar foo bar
2foo bar foo bar foo bar foo bar

El programa anterior hará lo siguiente:

• .z- Lo lee todo y lo divide por nuevas líneas, así que lo tenemos ['foo bar foo bar', '1foo bar foo bar foo bar', '2foo bar foo bar foo bar foo bar'].

• Obtenemos el primer carácter de cada uno: ['f', '1', '2'].

• Si es convertible a un entero, repetimos un espacio que es entero y suma el resto de la cadena. De lo contrario, simplemente colocamos toda la cadena. Por lo tanto, tenemos ['foo bar foo bar', ' foo bar foo bar foo bar', ' foo bar foo bar foo bar foo bar'].

• Finalmente, nos unimos por nuevas líneas, por lo que nuestro resultado es:

  foo bar foo bar
   foo bar foo bar foo bar
    foo bar foo bar foo bar foo bar
  

Cúbicamente , 82 bytes

R3D1R1D1+0(?6{?7@7~:1+2<7?6{+35>7?6{:7-120?6{(B3@5B1-0)6}:0}}}?6!@7~-60=7&6+4-3=7)

Nota: Esto no funcionará en TIO . Para probar esto, use el intérprete de Lua con el indicador experimental establecido en verdadero (para habilitar condicionales). Actualmente hay un error con bloques condicionales en el intérprete TIO. Cuando use el intérprete TIO, debe reemplazar ?6!con !6y &6con ?6&, lo que mantiene el recuento de bytes igual.

R3D1R1D1          Set the cube so that face 0 has value 1 and the rest of the values are easy to calculate

+0                Set the notepad to 1 so that it enters the conditional below
(                 Do
  ?6{               If the notepad is 1 (last character was \n or start of input)
    ?7@7              Output the current character if it's \n
    ~                 Get the next character
    :1+2<7?6{         If the input is >= '0'
      +35>7?6{          If the input is <= '9'
        :7-120            Set the notepad to the input - '0'
        ?6{               If the notepad isn't 0
          (                 Do
            B3@5              Output a space
            B1-0              Subtract 1 from notepad
          )6                While notepad > 0
        }                 End if
        :0              Set notepad to 1
      }                 End if
    }                 End if
  }                 End if

  ?6!@7             If the notepad is 0 (did not attempt to print spaces), print current character

  ~                 Get next character
  -60=7&6           If there is no more input, exit the program
  +4-3=7            Check if current character is \n, setting notepad to result
)                 Repeat forever

Esto no es tan corto como la otra respuesta cúbica, pero pensé en intentarlo de todos modos: D

> <> , 60 bytes

!^i:0(?;::"/")$":"(*0$.
v"0"-
>:?!v1-" "o
;>:o>a=&10&?.i:0(?

Pruébalo en línea!

Cómo funciona:

..i:0(?;... Gets input and ends if it is EOF
...
...
...

.^......::"/")$":"(*0$. If the inputted character is a digit go to the second line
...                     Else go to the fourth
...
...

....        If it was a digit
v"0"-       Subtract the character "0" from it to turn it into the corresponding integer
>:?!v1-" "o And print that many spaces before rejoining the fourth line
...

.^..               On the fourth line,
....               Copy and print the input (skip this if it was a digit)
....v              If the input is a newline, go back to the first line.
;>:o>a=&10&?.i:0(? Else get the input, ending on EOF

V , 9 bytes

ç^ä/x@"é 

Pruébalo en línea!

Explicación

ç  /      ' On lines matching
 ^ä       ' (Start)(digit)
    x     ' Delete the first character
     @"   ' (Copy Register) number of times
       é  ' Insert a space

Gema, 21 personajes

\N<D1>=@repeat{$1;\ }

Ejecución de muestra:

bash-4.4$ gema '\N<D1>=@repeat{$1;\ }' <<< 'foo bar foo bar
> 1foo bar foo bar foo bar
> 2foo bar foo bar foo bar foo bar
> 
> --------v
> 8|
> 8|
> 80
> 8,
> 7&'
foo bar foo bar
 foo bar foo bar foo bar
  foo bar foo bar foo bar foo bar

--------v
        |
        |
        0
        ,
       &

PHP, 83 caracteres

preg_replace_callback('/^\d/m',function($m){return str_repeat(' ',$m[0]);},$argv);