Khi mã hóa bằng Python, đôi khi bạn muốn có một chuỗi nhiều dòng trong một hàm, ví dụ:

def f():
    s = """\
    Line 1
    Line 2
    Line 3"""

^{(Dấu gạch chéo ngược là để xóa một dòng mới hàng đầu)}

sTuy nhiên, nếu bạn cố gắng thực sự in ra , bạn sẽ nhận được

    Line 1
    Line 2
    Line 3

Đó không phải là những gì chúng ta muốn! Có quá nhiều khoảng trắng hàng đầu!

Các thách thức

Đưa ra một chuỗi nhiều dòng chỉ bao gồm các ký tự chữ và số, dấu cách và dòng mới, loại bỏ tất cả các khoảng trắng chung từ đầu mỗi dòng. Mỗi dòng được đảm bảo có ít nhất một ký tự không phải khoảng trắng và sẽ không có dấu cách. Đầu ra có thể không có khoảng trắng bên ngoài, cho dù đó là trước hoặc sau toàn bộ đầu ra hoặc một dòng riêng lẻ (ngoại trừ một dòng mới theo dõi tùy chọn duy nhất).

Đầu vào có thể thông qua STDIN hoặc đối số chức năng và đầu ra có thể thông qua STDOUT hoặc giá trị trả về của hàm. Bạn không thể sử dụng bất kỳ nội dung nào được thiết kế để trích xuất các chuỗi đa dòng hoặc thực hiện tác vụ chính xác này, ví dụ: Python textwrap.dedent.

Đây là môn đánh gôn , vì vậy giải pháp trong vài byte nhất sẽ thắng. Tiêu chuẩn áp dụng.

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

"a"                                  ->   "a"
"   abc"                             ->   "abc"
"   abc\n def\n  ghi"                ->   "  abc\ndef\n ghi"
"    a\n    b\n    c"                ->   "a\nb\nc"
"    a\n    b\n    c\nd"             ->   "    a\n    b\n    c\nd"
"   a   b\n     c     d\n    e f"    ->   "a   b\n  c     d\n e f"

Ví dụ, trường hợp thử nghiệm cuối cùng là

   a   b
     c     d
    e f

và sẽ trông như thế này sau khi tước bỏ không gian hàng đầu:

a   b
  c     d
 e f

CJam, 20 14 byte

qN/_z{S-}#f>N*

Thuật toán :

• Trước tiên chúng tôi phân chia đầu vào trên dòng mới và lấy một bản sao ( qN/_)
• Sau đó, cột nhỏ nhất có ký tự không gian được tính bằng cách hoán chuyển mảng được phân tách dòng mới và sau đó chỉ cần tìm chỉ mục của hàng không phải là tất cả không gian đầu tiên ( z{S-}#)
• Sau đó, chúng tôi chỉ cần xóa nhiều ký tự khỏi mỗi dòng ( f>)
• Cuối cùng, chúng tôi tham gia bằng dòng mới một lần nữa ( N*)

Mở rộng mã

qN/               e# Read the entire input and split it on newline
   _z             e# Take a copy and transpose rows with columns.
                  e# Now we would have a bunch of all space rows. These rows are the ones
                  e# we want to remove (in form of columns) 
     {  }#        e# Get the index of the first item from the transposed array that returns
                  e# true for this block
      S-          e# From each part, remove spaces. If the part is all-space, it will return
                  e# an empty string, which is false in CJam. We finally will get the index
                  e# of the first non-all-space row (or column)
          f>      e# We take that index and remove that many characters from starting of each
                  e# row of the initial newline separated input
            N*    e# Join the array back using newlines and automatically print the result

Dùng thử trực tuyến tại đây

Pyth, 19 18 17 14 byte

jbu>R!rhCG6G.z

Việc thực hiện là khá mát mẻ.

1. u .zlấy tất cả các dòng stdin trong một mảng, đặt nó vào G. Sau đó, nó đánh giá cơ thể bên trong, đưa kết quả vào Gvà tiếp tục làm điều này cho đến khi nó không còn thay đổi (điểm cố định).

2. !rhCG6hoán vị G, lấy phần tử đầu tiên của mảng được chuyển (cột đầu tiên), loại bỏ phần tử của bất kỳ khoảng trắng nào và kiểm tra xem có còn ký tự không khoảng trắng nào không.

3. Giá trị từ 2 là boolean, có thể được xem là int 0 hoặc 1. >R Glấy số này và cắt bỏ nhiều ký tự bên trái của mỗi dòng G. Bước 1, 2 và 3 kết hợp về cơ bản có nghĩa là nó sẽ tiếp tục tước bỏ các cột của khoảng trắng cho đến khi không còn cột trắng nào.

4. jb nối các mảng của dòng bằng dòng mới và in nó.

sed - 26 byte

:;/(^|\n)\S/q;s/^ //mg;b

chạy với -rz

Khá đơn giản:

  /(^|\n)\S/q;           - quit if there is a line that starts with non-space
              s/^ //mg;  - remove exactly one space in each line
:;                     b - repeat

-rtùy chọn bật regexps mở rộng, -zđọc toàn bộ đầu vào dưới dạng một chuỗi (thực sự sử dụng NUL-byte làm dấu phân cách dòng)

SWI-Prolog, 233 223 217 byte

a(A):-b(A,0,0,0,N),w(A,N,0).
b([A|T],P,K,M,N):-P=1,(A=10,b(T,0,0,M,N);b(T,1,0,M,N));A\=32,(M=0;K<M),b(T,1,0,K,N);I=K+1,b(T,0,I,M,N).
b(_,_,_,N,N).
w([A|T],N,P):-P<N,A=32,Q=P+1,w(T,N,Q);put(A),A=10,w(T,N,0);w(T,N,P);!.

Chỉnh sửa : Hoàn toàn thay đổi câu trả lời của tôi. Bây giờ nó sử dụng mã ký tự thay vì chuỗi.

Một ví dụ về cách gọi này sẽ là a(` a b\n c d\n e f`)., với backquote. Bạn có thể cần phải sử dụng dấu ngoặc kép "thay thế nếu bạn có một bản phân phối SWI-Prolog cũ.

Julia, 93 92 81 byte

Đã lưu 10 byte nhờ Glen O.

s->for i=(p=split(s,"\n")) println(i[min([search(j,r"\S")[1]for j=p]...):end])end

Điều này tạo ra một hàm không tên chấp nhận một chuỗi và in ra thiết bị xuất chuẩn.

Ungolfed + giải thích:

function f(s)
    # Split s into an array on newlines
    p = split(s, "\n")

    # Get the smallest amount of leading space by finding the
    # position of the first non-space character on each line
    # and taking the minimum
    m = min([search(j, r"\S")[1] for j in p]...)

    # Print each line starting after m
    for i in p
        println(i[m:end])
    end
end

Java, 159

Bởi vì thiếu Java dễ thấy ...

void f(String...a){int s=1<<30,b;a=a[0].split("\n");for(String x:a)s=(b=x.length()-x.trim().length())<s?b:s;for(String x:a)System.out.println(x.substring(s));}

Nó chỉ là các vòng so sánh chiều dài với chiều dài được cắt, sau đó phun ra các chuỗi con. Không có gì quá lạ mắt. Đối với thanh cuộn bị suy yếu:

void f(String...a){
    int s=1<<30,b;
    a=a[0].split("\n");
    for(String x:a)
        s=(b=x.length()-x.trim().length())<s?b:s;       
    for(String x:a)
        System.out.println(x.substring(s));
}

Perl, 47 33

Cảm ơn @ ThisSuitIsBlackNot đã gợi ý sử dụng vòng lặp ẩn của Perl

#!/usr/bin/perl -00p
/^( +).*(\n\1.*)*$/&&s/^$1//mg

Ở trên được ghi là 30 byte cho dòng mã + 3 cho 00pcờ.

Phiên bản gốc, là một chức năng:

sub f{$_=@_[0];/^( +).*(\n\1.*)*$/&&s/^$1//mgr}

Điều này đặt đối số vào $_, sau đó cố gắng khớp một cách tham lam khoảng trắng có trên tất cả các dòng với /^( +).*(\n\1.*)*$/- nếu thành công, $1bây giờ chứa tiền tố chung dài nhất và chúng tôi thực hiện thay thế s/^$1//mgrđể xóa nó từ đầu mỗi dòng và trả về chuỗi kết quả.

Kiểm tra

$ cat 53219.data
   a   b
     c     d
    e f
$ ./53219.pl <53219.data 
a   b
  c     d
 e f

Python 2, 86 79 75 byte

Điều này gần như chắc chắn có thể được rút ngắn thêm một số, nhưng ngay bây giờ nó không phải là xấu.

Cảm ơn xnor vì đã tiết kiệm 4 byte!

s=input().split('\n')
for k in s:print k[min(x.find(x.strip())for x in s):]

Ruby: 77 73 70 66 65 58 57 40 ký tự

f=->t{t.gsub /^#{t.scan(/^ */).min}/,""}

Chạy mẫu:

irb(main):001:0> f=->t{t.gsub /^#{t.scan(/^ */).min}/,""}
=> #<Proc:0x00000001855948@(irb):1 (lambda)>

irb(main):002:0> puts f["   a   b\n     c     d\n    e f"]
a   b
  c     d
 e f
=> nil

irb(main):003:0> f["   a   b\n     c     d\n    e f"] == "a   b\n  c     d\n e f"
=> true

C #, 18 + 145 = 163 byte

Yêu cầu (18 byte):

using System.Linq;

Phương thức (145 byte):

string R(string s){var l=s.Split('\n');return string.Join("\n",l.Select(x=>string.Concat(x.Skip(l.Select(z=>z.Length-z.Trim().Length).Min()))));}

Phương thức tính toán lượng không gian hàng đầu thấp nhất trên các dòng và tạo ra một chuỗi mới được xây dựng cho tất cả các dòng, với N ký tự được bỏ qua (trong đó N là số được tính trước đó).

C #, tổng cộng 149 byte

Thực tế là giải pháp tương tự như của ProgramFOX, mặc dù số lượng ký tự cần cắt được tính thủ công.

using System.Linq;

Và chính chức năng:

string D(string s){var l=s.Split('\n');int i=0;while(l.All(a=>a[i]==' '))i++;return string.Join("\n",l.Select(b=>b.Substring(i)));}

Trăn 3, 100

def f(s):t=s.split("\n");return"\n".join([c[min([len(c)-len(c.lstrip(" "))for c in t]):]for c in t])

JavaScript, ES6, 89 86 byte

Điều này là hoàn toàn sử dụng chỉ phù hợp và thay thế RegEx.

f=x=>eval(`x.replace(/(^|\\n) {${--`
${x}`.match(/\n */g).sort()[0].length}}/g,"$1")`)

// Snippet related stuff
B.onclick=x=>P.innerHTML=f(T.value)

<textarea id=T></textarea><br>
<button id=B>Trim</button>
<pre id=P></pre>

Như mọi khi, chỉ có Firefox, kể từ ES6. Sẽ thêm phiên bản ES5 sau.

K, 31 byte

{`0:(&/{(0;#*=x)@*x}'" "=x)_'x}

Đưa vào danh sách các chuỗi và in kết quả ra thiết bị xuất chuẩn.

Haskell, 52 byte

unlines.until(any(/=' ').map head)(map tail).lines

Ví dụ sử dụng: unlines.until(any(/=' ').map head)(map tail).lines $ " abc\n def\n ghi"->" abc\ndef\n ghi\n"

Làm thế nào nó hoạt động:

                                           lines    -- split the input at newlines into a list of lines
        until                                       -- repeat the 2nd argument, i.e.
                                 map tails          -- cut off the heads of all lines
                                                    -- until the the first argument returns "True", i.e.
             any(/=' ').map head                    -- the list of heads contains at least one non-space
unlines                                             -- transform back to a single string with newlines in-between

Con trăn, 94/95

lambda (94 byte):

f=lambda s:'\n'.join(l[min(l.find(l.strip()) for l in s.split('\n')):] for l in s.split('\n'))

def (95 byte)

def f(s):l=s.split('\n');m=min(i.find(i.strip())for i in l);return '\n'.join(i[m:] for i in l);

bash + sed + coreutils, 74 , 56 , 55

Dữ liệu kiểm tra

s="\
   a   b
     c     d
    e f"

Câu trả lời

cut -c$[`grep -o '^ *'<<<"$s"|sort|line|wc -c`]-<<<"$s"

Đầu ra

a   b
  c     d
 e f

R 118 111 byte

Sử dụng các hàm chuỗi tuyệt vời của R :) Điều này tương tự / giống với các giải pháp khác đã được đăng. Đầu vào là thông qua STDIN và mèo đến STDOUT.

cat(substring(a<-scan(,'',sep='|'),Reduce(min,lapply(strsplit(a,' '),function(x)min(which(x>''))-1))),sep='\n')

Kiểm tra và giải thích

> cat(substring(a<-scan(,'',sep='|'),Reduce(min,lapply(strsplit(a,' '),function(x)min(which(x>''))-1))),sep='\n')
1:                  a<-scan(,'',sep='|') # get the input lines
2:                                                         strsplit(a,' ') # split lines on spaces
3:                                                  lapply(                ,function(x)min(which(x>''))-1) # get min index - 1 for non space of each line
4:                                      ,Reduce(min,                                                      ) # get the min of those
5:        substring(                                                                                       ) # trim it off
6:    cat(                                                                                                  ,sep='\n') # output each line
7:
Read 6 items
              a<-scan(,'',sep='|') # get the input lines
                                                     strsplit(a,' ') # split lines on spaces
                                              lapply(                ,function(x)min(which(x>''))-1) # get min index - 1 for non space of each line
                                  ,Reduce(min,                                                      ) # get the min of those
    substring(                                                                                       ) # trim it off
cat(                                                                                                  ,sep='\n') # output each line
> 

Julia, 72 62 61 57 54 49 byte

g=s->ismatch(r"^\S"m,s)?s:g(replace(s,r"^ "m,""))

Ung dung:

g(s)=
if ismatch(r"^\S"m,s)       # Determines if there's a newline followed by something other than a space
                            # Note: the m in r"^ "m says to work in multiline mode.
    s                       # If there is, return the string as the final result.
else                        # otherwise...
    m=replace(s,r"^ "m,"")  # Remove first space after each newline, and space at start of string.
    g(m)                    # Feed back into the function for recursion
end

Giải pháp cũ hơn (57 byte):

g(s)=ismatch(r"
\S","
"s)?s:g(replace(s,"
 ","
")[2:end])

Giải pháp gốc (72 byte):

g(s)=all([i[1]<33for i=split(s,"\n")])?g(replace(s,"\n ","\n")[2:end]):s

k (24 byte)

Lấy một chuỗi làm đối số và trả về một chuỗi (có dòng mới).

{`/:(&//&:'~^s)_'s:`\:x}

Thí dụ:

k) f:{`/:(&//&:'~^s)_'s:`\:x};
k) f"   a   b\n     c     d\n    e f"
"a   b\n  c     d\n e f\n

05AB1E , 10 byte

|©ζ®gð*Ûζ»

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

Gawk, 101 100

{match($0,/^( +)/,t);if(t[1]<s||s==""){s=t[1]};z[NR]=$0;}END{for(r in z){sub(s,"",z[r]);print z[r]}}

Ví dụ...

cat input.txt | gawk '{match($0,/^( +)/,t);if(t[1]<s||s==""){s=t[1]};z[NR]=$0;}END{for(r in z){sub(s,"",z[r]);print z[r]}}'

Đầu ra ...

a   b
  c     d
 e f

C GCC, 74 byte

main(_,z){z=1;while(-~(_=getchar()))putchar(_==32&&z?0:(z=_==10?1:0,_));}

Chỉ xóa tất cả các khoảng trắng, không liên quan đến các dòng trước đó, yêu cầu trợ giúp để kết thúc. CSONG, xét về các khoảng trắng thông thường, OP có nghĩa là dòng nào có ít khoảng trắng hàng đầu nhất, đó là số lượng khoảng trắng sẽ bị xóa khỏi mỗi dòng?

Xếp chồng , không biên dịch, 43 byte

:lines'^ +'match$#'"!MIN' '*0# '^'\+''mrepl

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

Điều này hoạt động bằng cách tìm số lượng khoảng trắng ở đầu mỗi dòng ( '^ +'match$#'"!), lấy mức tối thiểu, lặp lại một khoảng trắng nhiều lần và thay thế khoảng trống đó bằng không có gì trên mỗi dòng.

Vim, 33, 31 bytes

qq/\v%^(\s.*\n?)*%$
:%s/.
@qq@q## Heading ##

Try it online!

Old version:

qq:g/\v%^(\s.*\n?)*%$/%s/.
n@qq@q

Stax, 9 bytes

ü═≤+Σî║┘`

Run and debug it

CoffeeScript, 112 bytes

f=(x)->(a=x.split "\n").map((v)->v[Math.min.apply(null,a.map((v)->(r=/^ +/.exec v)&&r[0].length))...]).join "\n"

JavaScript (ES6), 106 98 bytes

The newlines are necessary and are counted as 1 byte each:

f=x=>(a=x.split`
`).map(v=>v.slice(Math.min(...a.map(v=>(r=/^ +/.exec(v))&&r[0].length)))).join`
`

Demo

As with other ES6 answers, they only work in Firefox at the moment.

f=x=>(a=x.split`
`).map(v=>v.slice(Math.min(...a.map(v=>(r=/^ +/.exec(v))&&r[0].length)))).join`
`

// For demonstration purposes
console.log = x => X.innerHTML += x + `\n<hr>`;

console.log(f("a"));
console.log(f("   abc"));
console.log(f("   abc\n def\n  ghi"));
console.log(f("    a\n    b\n    c"));
console.log(f("    a\n    b\n    c\nd"));
console.log(f("   a   b\n     c     d\n    e f"));

<pre id=X></pre>

JavaScript ES6, 85 bytes

s=>s.split`
`.map(z=>z.slice(Math.min(...s.match(/^ */gm).map(l=>l.length)))).join`
`

The new lines are significant

ES5 Demo:

function t(s) {
  return s.split("\n").map(function(z) {
    return z.slice(Math.min.apply(0, s.match(/^ */gm).map(function(l) {
      return l.length;
    })));
  }).join('');
}

// Demo
document.getElementById('go').onclick = function() {
  document.getElementById('r').innerHTML = t(document.getElementById('t').value)
};

Input:
<br>
<textarea id="t"></textarea>
<br>
<button id="go">Run</button>
<br>Output:
<br>
<pre style="background-color:#DDD;" id="r"></pre>

JavaScript (ES6) 56

Recursive, trying to remove one space at a time from each row until a non-space is found.

Test running the snippet below - being ES6, Firefox only

f=s=>(r=s.replace(/^./gm,x=>(k|=x>' ',''),k=0),k?s:f(r))

// Test
test=
[[ "a", "a" ]
,["   abc", "abc" ]
,["   abc\n def\n  ghi", "  abc\ndef\n ghi" ]
,["    a\n    b\n    c", "a\nb\nc" ]
,["    a\n    b\n    c\nd", "    a\n    b\n    c\nd" ]
,["   a   b\n     c     d\n    e f","a   b\n  c     d\n e f" ]]

var tb=''
test.forEach(t=>{
  t[2]=f(t[0])
  t[3]=t[2]==t[1]?'OK':'FAIL'
  tb+='<tr><td>'+t.join('</td><td>')+'</td></tr>'
})
B.innerHTML=tb

td { white-space: pre; font-family: monospace; border: 1px solid#444; vertical-align:top}
#I,#O { height:100px; width: 200px }

<b>Your test:</b>
<table><tr><td><textarea id=I></textarea></td>
<th><button onclick='O.innerHTML=f(I.value)'>-></button></th>
<td id=O></td></tr></table>
<b>Test cases:</b><br>
<table ><tr><th>Input</th><th>Expected</th><th>Output</th><th>Result</th></tr>
<tbody id=B></tbody></table>