Một số esolang hai chiều, chẳng hạn như Forked và một số non-esolang, chẳng hạn như Python , đôi khi có thể yêu cầu khoảng trắng trước các dòng mã. Đây không phải là rất golf. _{^{Ngoài ra, tôi lười biếng và viết một lang 2d cần nhiều khoảng trống trước khi viết mã.}} Nhiệm vụ của bạn là viết một công cụ làm cho những ngôn ngữ này trở nên golf hơn.

Tất nhiên, điều này sẽ không hoàn hảo; nó không thể được sử dụng, ví dụ, khi một số là ký tự đầu tiên trên một dòng nguồn. Tuy nhiên, nó thường sẽ hữu ích.

Thử thách

Bạn sẽ viết một chương trình hoặc chức năng ...

• ... có một đối số, tên tệp hoặc chuỗi hoặc ...
• ... Đọc từ đầu vào tiêu chuẩn.

Chương trình của bạn sẽ hoạt động như thế nào cat, ngoại trừ:

• Nếu ký tự đầu tiên trên bất kỳ dòng nào là một số, mã của bạn sẽ in x khoảng trắng, trong đó x là số đó.
• Nếu không, nó sẽ chỉ được in.
• Như mọi nhân vật khác trong đầu vào.

Các trường hợp thử nghiệm

Đầu vào:

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

Đầu ra:

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

Đầu vào:

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

Đầu ra:

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

Đầu vào:

foo bar
bar foo
foo bar

Đầu ra:

foo bar
bar foo
foo bar

Đầu vào:

0123456789
1234567890
2345678901
3456789012
4567890123

Đầu ra:

123456789
 234567890
  345678901
   456789012
    567890123

Quy tắc

• Đầu ra phải chính xác như đầu vào, ngoại trừ các dòng có ký tự đầu tiên là một số.
• Chương trình của bạn không thể nối thêm / thêm bất cứ thứ gì vào tệp, ngoại trừ một dòng mới nếu bạn muốn.
• Chương trình của bạn có thể không đưa ra giả định nào về đầu vào. Nó có thể chứa các dòng trống, không có số, ký tự Unicode, bất cứ thứ gì.
• Nếu một số có nhiều hơn một chữ số bắt đầu một dòng (ví dụ 523abcdefg), chỉ chữ số đầu tiên (trong ví dụ, 5) mới biến thành khoảng trắng.

Người chiến thắng

Mã ngắn nhất trong mỗi ngôn ngữ sẽ thắng. Chuc vui vẻ va nhiêu may măn nhe!

Võng mạc , 9 byte

m`^\d
$* 

Hãy thử trực tuyến! Lưu ý: Trailing space trên dòng cuối cùng.

Về cơ bản , 69 byte

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

Hãy thử trực tuyến!

Giải trình:

Đầu tiên chúng tôi thực hiện việc khởi tạo này:

R1B1R3B1

Để thiết lập khối này:

   533
   004
   000
411223455441
311222331440
311222331440
   555
   555
   200

Điều quan trọng nhất về khối lập phương này là 5tổng số mặt là 32, là giá trị cần thiết để in dấu cách. Thật trùng hợp, nó cũng xảy ra khá ngắn đối với tất cả các tính toán khác. Sau đó là xong:

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

Husk , 15 13 byte

-2 byte nhờ @Zgarb

mΓo+?oR' i;±¶

Hãy thử trực tuyến!

Sử dụng kỹ thuật tương tự như @Jonathan Allan

Giải trình

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

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

Tôi không nghĩ rằng nó có thể được cải thiện nhiều hơn nữa.
Đã lưu 1 byte nhờ Shaggy - Sử dụng các tính năng ES8.

Python 2 , 98 74 67 65 byte

-24 byte nhờ Jonathan Allan. -7 byte nhờ ông Xcoder.

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

Hãy thử trực tuyến!

Đưa đầu vào trong tệp có tên f.

Ruby , 24 21 + 1 = 25 22 byte

Sử dụng -pcờ. -3 byte từ GB.

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

Hãy thử trực tuyến!

05AB1E , 10 byte

v0y¬dićú},

Hãy thử trực tuyến!

Python 3 , 95 byte

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

Hãy thử trực tuyến!

-4 byte bằng cách đánh cắp ý tưởng regex từ ThePirateBay

Thạch , 19 byte

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

Một liên kết đơn lấy và trả về danh sách các ký tự hoặc một chương trình đầy đủ in kết quả.

Hãy thử trực tuyến!

Làm sao?

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

Try it online!

Haskell, 63 bytes

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

Try it online! The first line is an anonymous function which splits a given string into lines, applies the function g to each line and joins the resulting lines with newlines. In g it is checked whether the first character x of a line is a digit. If this is the case, then ['1'..x] yields a string with length equal to the value of the digit x and ' '<$ converts the string into as many spaces. Finally the rest of the line r is appended. If x is not a digit we are in the second equation g s=s and return the line unmodified.

Python 2, 76 72 68 bytes

-4 bytes thanks to @ovs!

@DeadPossum suggested switching to Python 2, which saved 4 bytes too.

Just thought it's nice to have a competitive full program in Python 2 that does not explicitly check if the first character is a digit. This reads the input from a file, f.

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

Try it online! (courtesy of @ovs)

Java 8, 105 99 97 93 bytes

Saved few more bytes thanks to Nevay's suggestion,

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 thanks to 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='
')

This is pretty bad, but it's a bit better now... R is, once again, terrible at strings.

Try it online!

Japt (v2.0a0), 11 10 bytes

Japt beating Jelly and 05AB1E? That doesn't seem right!

r/^\d/m_°ç

Test it

Explanation

Implicit input of string U

r/^\d/m

Use Regex replace (r) all occurrences of a digit at the beginning of a line (m is the multiline flag - the g flag is enabled by default in Japt).

_

Pass each match through a function, where Z is the current element.

°

The postfix increment operator (++). This converts Z to an integer without increasing it for the following operation.

ç

Repeat a space character Z times.

Implicitly output the resulting string.

Jelly, 19 bytes

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

Try it online!

-5 bytes total thanks to Jonathan Allan's comments and by looking at his post

Explanation

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

Try it online!

Explanation

jm.x+*;shdtdd.z   - Full program that works by reading everything from STDIN.

             .z  - Read all STDIN and split it by linefeeds.
 m               - Map with a variable d.
  .x             - Try:
     *;shd           - To convert the first character to an Integer and multiply it by a space.
    +     td         - And add everything except for the first character
            d        - If the above fails, just add the whole String.
j                 - Join by newlines.

Let's take an example that should be easier to process. Say our input is:

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

The program above will do the following:

• .z - Reads it all and splits it by newlines, so we get ['foo bar foo bar', '1foo bar foo bar foo bar', '2foo bar foo bar foo bar foo bar'].

• We get the first character of each: ['f', '1', '2'].

• If it is convertible to an integer, we repeat a space that integer times and add the rest of the String. Else, we just place the whole String. Hence, we have ['foo bar foo bar', ' foo bar foo bar foo bar', ' foo bar foo bar foo bar foo bar'].

• Finally, we join by newlines, so our result is:

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

Cubically, 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)

Note: This will not work on TIO. To test this, use the Lua interpreter with the experimental flag set to true (to enable conditionals). There's currently a bug with conditional blocks on the TIO interpreter. When using the TIO interpreter, you should replace ?6! with !6 and &6 with ?6&, which keeps the byte count the same.

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

This isn't as short as the other Cubically answer, but I thought I'd give this a try anyway :D

><>, 60 bytes

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

Try it online!

How It Works:

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

Try it online!

Explanation

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

Gema, 21 characters

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

Sample run:

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 chars

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