파이썬으로 코딩 할 때 때로는 함수 내에 여러 줄 문자열을 원합니다.

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

^{(백 슬래시는 선행 줄 바꿈을 제거하는 것입니다)}

s그러나 실제로 인쇄하려고 하면 얻을 수 있습니다.

    Line 1
    Line 2
    Line 3

그것은 우리가 전혀 원하는 것이 아닙니다! 선행 공백이 너무 많습니다!

도전

영숫자 문자, 공백 및 줄 바꾸기로 구성된 여러 줄 문자열이 제공되면 각 줄의 시작 부분에서 모든 공통 공백을 제거하십시오. 각 줄에는 공백이 아닌 문자가 하나 이상 있어야하며 뒤에 공백이 없습니다. 출력은 전체 출력 또는 개별 행 전후에 관계없이 공백이 없을 수 있습니다 (단일 선택적 후행 줄 바꿈 제외).

입력은 STDIN 또는 함수 인수를 통해 이루어질 수 있으며, 출력은 STDOUT 또는 함수 리턴 값을 통해 이루어질 수 있습니다. 당신은 할 수 dedent 여러 문자열로 설계되는 모든 내장 명령을 사용하거나이 정확한 작업, 예를 들어 파이썬을 수행 textwrap.dedent.

이것은 code-golf 이므로 가장 적은 바이트의 솔루션이 이깁니다. 표준 허점이 적용됩니다.

테스트 사례

"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 .zstdin의 모든 줄을 배열에 담아 넣습니다 G. 그런 다음 내부 몸체를 평가하고 결과를에 넣고 G더 이상 변경되지 않을 때까지 계속 고정합니다 (고정 점).

2. !rhCG6transposes G는 전치 된 배열의 첫 번째 요소 (첫 번째 열)를 가져 와서 공백을 제거하고 공백이 아닌 문자가 남아 있는지 확인합니다.

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옵션은 확장 정규 -z표현식을 켜고 전체 입력을 단일 문자열로 읽습니다 (실제로 NUL 바이트를 행 구분 기호로 사용합니다)

SWI-도입부 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`).따옴표로 묶는 예는 입니다. "오래된 SWI-Prolog 배포가있는 경우 큰 따옴표를 대신 사용해야 할 수도 있습니다 .

줄리아, 93 92 81 바이트

Glen O 덕분에 10 바이트 절약

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

이것은 문자열을 받아들이고 stdout으로 인쇄하는 명명되지 않은 함수를 만듭니다.

언 골프 + 설명 :

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

펄, 47 33

Perl의 암시 적 루프를 사용하도록 제안 해 주셔서 감사합니다 @ThisSuitIsBlackNot

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

위의 코드 줄에 대해 30 바이트 + 00p플래그에 대해 3으로 점수가 매겨집니다 .

함수로서의 오리지널 버전 :

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

파이썬 2, 86 79 75 바이트

이것은 거의 확실히 더 짧아 질 수 있지만 지금은 나쁘지 않습니다.

4 바이트를 절약 한 xnor에게 감사합니다!

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

파이썬 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])

자바 스크립트, 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>

항상 그렇듯이 ES6부터 Firefox 만 해당됩니다. 나중에 ES5 버전을 추가합니다.

K, 31 바이트

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

문자열 목록을 입력하고 stdout에 결과를 인쇄합니다.

하스켈, 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

파이썬, 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'))

데프 (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, 118111 바이트

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
> 

줄리아, 72 62 61 57 54 49 바이트

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

언 골프 드 :

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ð*Ûζ»

온라인으로 사용해보십시오!

둔한, 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$#'"!) 최소값을 얻고, 여러 번 공백을 반복하고, 각 행의 공백으로 대체하여 작동합니다.

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

자바 스크립트 (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>

자바 스크립트 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>

자바 스크립트 ( 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>