Einige zweidimensionale Esolangs wie Forked und einige Nicht-Esolangs wie Python können manchmal Leerzeichen vor Codezeilen erfordern. Das ist nicht sehr golfen. _{^{Außerdem bin ich faul und schreibe eine 2D-Sprache, die vor dem Code viele Leerzeichen benötigt.}} Ihre Aufgabe ist es, ein Tool zu schreiben, mit dem Sie diese Sprachen Golf spielen können.

Natürlich wird dies nicht perfekt sein; Sie kann beispielsweise nicht verwendet werden, wenn eine Zahl das erste Zeichen in einer Quellzeile ist. Es wird jedoch im Allgemeinen nützlich sein.

Herausforderung

Sie werden ein Programm oder eine Funktion schreiben, die entweder ...

• ... nimmt ein Argument, einen Dateinamen oder eine Zeichenfolge, oder ...
• ... liest aus der Standardeingabe.

Ihr Programm verhält sich wie folgt cat:

• Wenn das erste Zeichen in einer Zeile eine Zahl ist, gibt Ihr Code x Leerzeichen aus, wobei x diese Zahl ist.
• Andernfalls wird es einfach gedruckt.
• Wie jedes andere Zeichen in der Eingabe.

Testfälle

Eingang:

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

Ausgabe:

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

Eingang:

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

Ausgabe:

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

Eingang:

foo bar
bar foo
foo bar

Ausgabe:

foo bar
bar foo
foo bar

Eingang:

0123456789
1234567890
2345678901
3456789012
4567890123

Ausgabe:

123456789
 234567890
  345678901
   456789012
    567890123

Regeln

• Die Ausgabe muss genau wie die Eingabe erfolgen, außer in Zeilen, in denen das erste Zeichen eine Zahl ist.
• Ihr Programm kann nichts an die Datei anhängen / voranstellen, außer eine abschließende Newline, wenn Sie dies wünschen.
• Ihr Programm kann keine Annahmen über die Eingabe treffen. Es kann leere Zeilen, keine Zahlen oder Unicode-Zeichen enthalten.
• Beginnt eine Zahl mit mehr als einer Ziffer eine Zeile (z. B. 523abcdefg), sollte nur die erste Ziffer (im Beispiel 5) in Leerzeichen umgewandelt werden.

Gewinner

Der kürzeste Code in jeder Sprache gewinnt. Viel Spaß und viel Glück!

Netzhaut , 9 Bytes

m`^\d
$* 

Probieren Sie es online! Hinweis: Leerzeichen in der letzten Zeile.

Kubisch 69 Bytes

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

Probieren Sie es online!

Erläuterung:

Zuerst führen wir diese Initialisierung durch:

R1B1R3B1

So richten Sie diesen Cube ein:

   533
   004
   000
411223455441
311222331440
311222331440
   555
   555
   200

Das Wichtigste an diesem Würfel ist, dass 5die Summe der Flächen 32 ist. Dies ist der Wert, der zum Drucken von Leerzeichen erforderlich ist. Zufälligerweise ist es auch für alle anderen Berechnungen ziemlich kurz. Nachdem das erledigt ist:

~( . . . )                                    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

Schale , 15 bis 13 Bytes

-2 Bytes dank @Zgarb

mΓo+?oR' i;±¶

Probieren Sie es online!

Verwendet die gleiche Technik wie @Jonathan Allan

Erläuterung

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

Ich denke nicht, dass es noch viel besser werden kann.
Dank Shaggy 1 Byte gespart - Verwenden Sie ES8-Funktionen.

Python 2 , 98 74 67 65 Bytes

-24 Bytes dank Jonathan Allan. -7 Bytes dank Mr. Xcoder.

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

Probieren Sie es online!

Übernimmt die Eingabe in der genannten Datei f.

Ruby , 24 21 + 1 = 25 22 Bytes

Verwendet die -pFlagge. -3 Bytes von GB.

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

Probieren Sie es online!

05AB1E , 10 Bytes

v0y¬dićú},

Probieren Sie es online!

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

Probieren Sie es online!

-4 Bytes durch Diebstahl der Regex-Idee von ThePirateBay

Jelly , 19 Bytes

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

Eine monadische Verknüpfung, die eine Liste von Zeichen aufnimmt und zurückgibt, oder ein vollständiges Programm, das das Ergebnis druckt.

Probieren Sie es online!

Wie?

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

Probieren Sie es online!

Haskell , 63 Bytes

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

Probieren Sie es online! Die erste Zeile ist eine anonyme Funktion, die einen bestimmten String in Zeilen gaufteilt , die Funktion auf jede Zeile anwendet und die resultierenden Zeilen mit neuen Zeilen verbindet. Darin gwird geprüft, ob das erste Zeichen xeiner Zeile eine Ziffer ist. Wenn dies der Fall ist, wird ['1'..x]eine Zeichenfolge mit der gleichen Länge wie der Wert der Ziffer ausgegeben xund ' '<$die Zeichenfolge in so viele Leerzeichen konvertiert. Schließlich wird der Rest der Zeile rangehängt. Wenn xes sich nicht um eine Ziffer handelt, befinden wir uns in der zweiten Gleichung g s=sund geben die Zeile unverändert zurück.

Python 2 , 76 72 68 Bytes

-4 Bytes dank @ovs !

@DeadPossum schlug vor, auf Python 2 zu wechseln, wodurch ebenfalls 4 Byte eingespart wurden.

Ich dachte nur, es ist schön, in Python 2 ein konkurrenzfähiges Vollprogramm zu haben, das nicht explizit prüft, ob das erste Zeichen eine Ziffer ist. Hiermit wird die Eingabe aus einer Datei gelesen f.

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

Probieren Sie es online! (mit freundlicher Genehmigung von @ovs )

Java 8 , 105 99 97 93 Bytes

Dank des Vorschlags von Nevay konnten noch einige Bytes eingespart werden.

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 dank 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='
')

Das ist ziemlich schlimm, aber jetzt ist es ein bisschen besser ... R ist wieder schrecklich in Streichern.

Probieren Sie es online!

Japt (v2.0a0), 11 10 Bytes

Japt schlägt Jelly und 05AB1E? Das scheint nicht richtig zu sein!

r/^\d/m_°ç

Probier es aus

Erläuterung

Implizite Eingabe eines Strings U

r/^\d/m

Verwenden Sie Regex replace ( r), um alle Vorkommen einer Ziffer am Anfang einer Zeile zu ersetzen ( mist das mehrzeilige Flag - das gFlag ist in Japt standardmäßig aktiviert).

_

Führen Sie jedes Match durch eine Funktion, in der Zsich das aktuelle Element befindet.

°

Der Postfix-Inkrement-Operator ( ++). Dies wird Zin eine Ganzzahl konvertiert , ohne sie für die folgende Operation zu erhöhen.

ç

Wiederholen Sie ein Leerzeichen Z.

Die resultierende Zeichenfolge implizit ausgeben.

Jelly , 19 Bytes

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

Probieren Sie es online!

Insgesamt -5 Bytes dank Jonathan Allans Kommentaren und dem Blick auf seinen Beitrag

Erläuterung

Ḣ⁶ẋ;µ¹µḣ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

Probieren Sie es online!

Erläuterung

jm.x + *; shdtdd.z - Vollständiges Programm, das alles von STDIN liest.

             .z - Lies alle STDINs und teile sie nach Zeilenvorschüben auf.
 m - Karte mit einer Variablen d.
  .x - Versuchen Sie:
     *; shd - Konvertiert das erste Zeichen in eine Ganzzahl und multipliziert es mit einem Leerzeichen.
    + td - Und füge alles außer dem ersten Zeichen hinzu
            d - Wenn dies fehlschlägt, fügen Sie einfach den gesamten String hinzu.
j - Join von Zeilenumbrüchen.

Nehmen wir ein Beispiel, das einfacher zu verarbeiten sein sollte. Sagen wir, unser Input ist:

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

Das obige Programm führt Folgendes aus:

• .z- Liest alles und teilt es in Zeilenumbrüche auf, damit wir bekommen ['foo bar foo bar', '1foo bar foo bar foo bar', '2foo bar foo bar foo bar foo bar'].

• Wir bekommen das erste Zeichen des einzelnen: ['f', '1', '2'].

• Wenn es in eine Ganzzahl konvertierbar ist, wiederholen wir ein Leerzeichen, das ganzzahlig ist, und fügen den Rest der Zeichenfolge hinzu. Ansonsten platzieren wir einfach den ganzen String. Daher haben wir ['foo bar foo bar', ' foo bar foo bar foo bar', ' foo bar foo bar foo bar foo bar'].

• Schließlich schließen wir uns durch Zeilenumbrüche an, sodass unser Ergebnis lautet:

  Foo Bar Foo Bar
   Foo Bar Foo Bar Foo Bar
    Foo Bar Foo Bar Foo Bar Foo Bar
  

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

Hinweis: Dies funktioniert nicht mit TIO . Um dies zu testen, verwenden Sie den Lua-Interpreter, wobei das experimentelle Flag auf true gesetzt ist (um Bedingungen zu aktivieren). Es gibt derzeit einen Fehler mit bedingten Blöcken im TIO-Interpreter. Wenn Sie den TIO-Interpreter verwenden, sollten Sie ?6!mit !6und &6mit ersetzen ?6&, damit die Byteanzahl gleich bleibt.

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

Dies ist nicht so kurz wie die andere kubische Antwort, aber ich dachte, ich würde es trotzdem versuchen: D

> <> 60 Bytes

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

Probieren Sie es online!

Wie es funktioniert:

..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@"é 

Probieren Sie es online!

Erläuterung

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

Gema, 21 Zeichen

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

Probelauf:

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 Zeichen

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