เมื่อเขียนโค้ดใน Python บางครั้งคุณต้องการสตริงหลายบรรทัดภายในฟังก์ชันเช่น

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

^{(แบ็กสแลชคือการลบ newline ชั้นนำ)}

อย่างไรก็ตามหากคุณพยายามที่จะพิมพ์ออกมาจริง ๆsคุณจะได้รับ

    Line 1
    Line 2
    Line 3

นั่นไม่ใช่สิ่งที่เราต้องการเลย! มีช่องว่างนำหน้ามากเกินไป!

ความท้าทาย

รับสตริงหลายบรรทัดที่ประกอบด้วยอักขระตัวอักษรและตัวเลขช่องว่างและบรรทัดใหม่เท่านั้นลบช่องว่างทั่วไปออกจากจุดเริ่มต้นของแต่ละบรรทัด แต่ละบรรทัดรับประกันว่าจะมีอักขระที่ไม่ใช่ช่องว่างอย่างน้อยหนึ่งตัวและจะไม่มีช่องว่างต่อท้าย เอาต์พุตอาจไม่มีช่องว่างภายนอกไม่ว่าจะเป็นก่อนหรือหลังเอาต์พุตทั้งหมดหรือแต่ละบรรทัด (ยกเว้นบรรทัดใหม่ที่เป็นทางเลือกหนึ่งบรรทัด)

อินพุตอาจผ่าน STDIN หรือฟังก์ชันอาร์กิวเมนต์และเอาต์พุตอาจผ่าน STDOUT หรือฟังก์ชันส่งคืนค่า คุณไม่สามารถใช้ builtins ใด ๆ ที่ถูกออกแบบมาเพื่อสตริงหลาย dedent textwrap.dedentหรือดำเนินงานตรงนี้เช่นงูหลาม

นี่คือรหัสกอล์ฟดังนั้นการแก้ปัญหาในไบต์ที่น้อยที่สุดชนะ ช่องโหว่มาตรฐานใช้

กรณีทดสอบ

"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"

ตัวอย่างเช่นกรณีทดสอบสุดท้ายคือ

   a   b
     c     d
    e f

และควรมีลักษณะเช่นนี้หลังจากลอกช่องว่างนำหน้า:

a   b
  c     d
 e f

CJam, 20 14 ไบต์

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

อัลกอริทึม :

• ก่อนอื่นเราแบ่งอินพุตบนบรรทัดใหม่และคัดลอก ( qN/_)
• จากนั้นคอลัมน์ที่เล็กที่สุดที่มีอักขระที่ไม่ใช่ช่องว่างจะถูกคำนวณโดยการย้ายอาเรย์ที่คั่นด้วยบรรทัดใหม่แล้วค้นหาดัชนีของแถวที่ไม่ได้เว้นวรรคแรก ( z{S-}#)
• จากนั้นเราก็ลบอักขระจำนวนมากออกจากแต่ละบรรทัด ( f>)
• ในที่สุดเราก็เข้าร่วมโดยขึ้นบรรทัดใหม่อีกครั้ง ( N*)

การขยายรหัส

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

ลองออนไลน์ได้ที่นี่

Pyth, 19 18 17 14 ไบต์

jbu>R!rhCG6G.z

การใช้งานค่อนข้างเย็น

1. u .zคว้าทุกบรรทัดของ stdin Gในอาร์เรย์ทำให้มันอยู่ใน จากนั้นจะประเมินเนื้อความด้านในวางผลลัพธ์Gและทำเช่นนี้ต่อไปจนกว่าจะไม่มีการเปลี่ยนแปลงอีกต่อไป (จุดคงที่)

2. !rhCG6transposes Gรับองค์ประกอบแรกของอาร์เรย์ transposed (คอลัมน์แรก) ตัดมันออกจากช่องว่างใด ๆ และตรวจสอบว่ามีอักขระที่ไม่ใช่ช่องว่างเหลืออยู่หรือไม่

3. ค่าจาก 2 เป็นแบบบูลซึ่งสามารถมองเห็นได้ในฐานะที่เป็น int 0 หรือ 1 คว้าหมายเลขนี้และชิ้นออกว่าตัวละครหลายปิดด้านซ้ายของแต่ละบรรทัดใน>R G Gขั้นที่ 1, 2 และ 3 รวมกันโดยทั่วไปหมายความว่ามันจะทำการแยกคอลัมน์ของช่องว่างออกจนกว่าจะไม่มีคอลัมน์ช่องว่างที่บริสุทธิ์เหลืออยู่

4. jb เข้าร่วมอาร์เรย์ของบรรทัดโดยการขึ้นบรรทัดใหม่และพิมพ์

sed - 26 ไบต์

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

ทำงานด้วย -rz

ตรงไปตรงมาสวย:

  /(^|\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

-rตัวเลือกเปิดใช้งาน regexps แบบขยาย-zอ่านอินพุตทั้งหมดเป็นสตริงเดี่ยว (จริง ๆ แล้วใช้ NUL-byte เป็นตัวคั่นบรรทัด)

SWI-Prolog, 233 223 217 ไบต์

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);!.

แก้ไข : เปลี่ยนคำตอบของฉันโดยสิ้นเชิง ตอนนี้ใช้รหัสอักขระแทนสตริง

ตัวอย่างของการเรียกสิ่งนี้a(` a b\n c d\n e f`).คือ backquotes คุณอาจจำเป็นต้องใช้เครื่องหมายคำพูดคู่"แทนถ้าคุณมี SWI-Prolog distrib เก่า

Julia, 93 92 81 ไบต์

บันทึก 10 ไบต์ด้วย Glen O.

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

สิ่งนี้จะสร้างฟังก์ชั่นที่ไม่มีชื่อที่ยอมรับสตริงและพิมพ์ไปยัง stdout

คำอธิบาย Ungolfed +:

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

ชวา, 159

เนื่องจากมีการขาด Java ที่เห็นได้ชัดเจน ...

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));}

มันเป็นแค่ลูปการเปรียบเทียบความยาวกับความยาวที่ถูกตัด ไม่มีอะไรแฟนซีเกินไป สำหรับแถบเลื่อนที่บกพร่อง:

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

ขอบคุณ @ThisSuitIsBlackNot สำหรับคำแนะนำในการใช้การบอกเป็นนัยของ Perl

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

ด้านบนถูกทำคะแนนเป็น 30 ไบต์สำหรับบรรทัดของรหัส + 3 สำหรับ00pค่าสถานะ

รุ่นเดิมเป็นฟังก์ชั่น:

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

สิ่งนี้ทำให้เกิดการโต้แย้ง$_จากนั้นพยายามจับคู่ช่องว่างที่มีอยู่ในทุกบรรทัดด้วย/^( +).*(\n\1.*)*$/ถ้าสำเร็จ$1ตอนนี้จะมีคำนำหน้าทั่วไปที่ยาวที่สุดและเราดำเนินการแทนที่s/^$1//mgrเพื่อลบมันออกจากจุดเริ่มต้นของทุกบรรทัดและส่งคืนสตริงผลลัพธ์

ทดสอบ

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

Python 2, 86 79 75 Bytes

สิ่งนี้สามารถย่อให้สั้นลงได้บ้าง แต่ตอนนี้ไม่เลวเลย

ขอบคุณ xnor สำหรับการบันทึก 4 ไบต์!

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

ทับทิม: 77 73 70 66 65 58 57 40 ตัวอักษร

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

วิ่งตัวอย่าง:

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 ไบต์

ต้องการ (18 ไบต์):

using System.Linq;

วิธีการ (145 ไบต์):

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()))));}

วิธีการคำนวณจำนวนช่องว่างนำหน้าสุดในบรรทัดและสร้างสตริงใหม่ที่สร้างขึ้นจากทุกบรรทัดโดยที่ไม่มีตัวอักษรNข้าม (โดยที่Nคือหมายเลขที่คำนวณก่อนหน้านี้)

ผลรวม C #, 149 ไบต์

หาแนวทางแก้ไขปัญหาเดียวกับของ ProgramFOX แม้ว่าจำนวนตัวอักษรที่จะตัดแต่งจะถูกคำนวณด้วยตนเอง

using System.Linq;

และฟังก์ชั่นของตัวเอง:

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)));}

Python 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 ไบต์

อันนี้ใช้การจับคู่และการแทนที่ 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>

เช่นเคย Firefox เท่านั้นตั้งแต่ ES6 จะเพิ่มรุ่น ES5 ในภายหลัง

K, 31 ไบต์

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

รับอินพุตสตริงและพิมพ์ผลลัพธ์ไปที่ stdout

Haskell, 52 ไบต์

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

ตัวอย่างการใช้: unlines.until(any(/=' ').map head)(map tail).lines $ " abc\n def\n ghi"->" abc\ndef\n ghi\n"

มันทำงานอย่างไร:

                                           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

Python, 94/95

แลมบ์ดา (94 ไบต์):

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 ไบต์)

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

ทดสอบข้อมูล

s="\
   a   b
     c     d
    e f"

ตอบ

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

เอาท์พุต

a   b
  c     d
 e f

R, 118 111 bytes

การใช้ฟังก์ชั่นสตริงที่ยอดเยี่ยมของ R :) นี่มันคล้ายกัน / เหมือนกับโซลูชั่นอื่น ๆ ที่โพสต์ไปแล้ว การป้อนข้อมูลผ่าน STDIN และแมวไปยัง STDOUT

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

ทดสอบและคำอธิบาย

> 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 ไบต์

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

Ungolfed:

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

โซลูชันที่เก่ากว่า (57 ไบต์):

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

โซลูชันดั้งเดิม (72 ไบต์):

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

k (24 ไบต์)

รับค่าสตริงเป็นอาร์กิวเมนต์และส่งคืนสตริง (ด้วยการขึ้นบรรทัดใหม่)

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

ตัวอย่าง:

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 ไบต์

|©ζ®gð*Ûζ»

ลองออนไลน์!

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]}}

ตัวอย่างเช่น...

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]}}'

เอาท์พุท ...

a   b
  c     d
 e f

C GCC, 74 ไบต์

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

ลบช่องว่างทั้งหมดเท่านั้นไม่เกี่ยวข้องกับบรรทัดก่อนหน้าขอความช่วยเหลือให้เสร็จ นอกจากนี้ในแง่ของช่องว่างทั่วไป OP หมายความว่าบรรทัดใดมีช่องว่างนำหน้าน้อยที่สุดนั่นคือจำนวนช่องว่างที่จะลบออกจากแต่ละบรรทัดหรือไม่

สแต็ก , ไม่ใช่การแข่งขัน, 43 ไบต์

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

ลองออนไลน์!

วิธีนี้ใช้งานได้โดยค้นหาจำนวนช่องว่างที่จุดเริ่มต้นของแต่ละบรรทัด ( '^ +'match$#'"!) รับค่าต่ำสุดทำซ้ำช่องว่างซ้ำหลายครั้งและแทนที่ด้วยพื้นที่ว่างในแต่ละบรรทัด

เป็นกลุ่ม, 33 , 31 ไบต์

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

ลองออนไลน์!

เวอร์ชั่นเก่า:

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

Stax , 9 ไบต์

ü═≤+Σî║┘`

เรียกใช้และแก้ไขข้อบกพร่อง

CoffeeScript, 112 ไบต์

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 ไบต์

ขึ้นบรรทัดใหม่มีความจำเป็นและนับเป็น 1 ไบต์ต่อ:

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

การสาธิต

เช่นเดียวกับคำตอบ ES6 อื่น ๆ พวกเขาทำงานเฉพาะใน Firefox ในขณะนี้

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 ไบต์

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

บรรทัดใหม่มีความสำคัญ

การสาธิต ES5:

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

เรียกใช้ซ้ำพยายามลบหนึ่งช่องว่างในแต่ละครั้งออกจากแต่ละแถวจนกว่าจะพบช่องว่าง

ทดสอบการเรียกใช้ข้อมูลโค้ดด้านล่าง - เป็น ES6, Firefox เท่านั้น

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>