Wenn Sie in Python codieren, möchten Sie manchmal einen mehrzeiligen String in einer Funktion, z

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

^{(Der Backslash ist das Entfernen eines führenden Zeilenumbruchs)}

Wenn Sie jedoch versuchen, tatsächlich auszudrucken s, erhalten Sie

    Line 1
    Line 2
    Line 3

Das wollen wir überhaupt nicht! Es gibt zu viel führendes Leerzeichen!

Die Herausforderung

Entfernen Sie bei einer mehrzeiligen Zeichenfolge, die nur aus alphanumerischen Zeichen, Leerzeichen und Zeilenumbrüchen besteht, alle gemeinsamen Leerzeichen am Anfang jeder Zeile. Jede Zeile muss mindestens ein Nicht-Leerzeichen enthalten und darf keine nachgestellten Leerzeichen enthalten. Die Ausgabe darf keine Leerzeichen enthalten, sei es vor oder nach der gesamten Ausgabe oder einer einzelnen Zeile (mit Ausnahme einer einzelnen optionalen nachgestellten Zeile).

Die Eingabe kann über STDIN oder ein Funktionsargument erfolgen, und die Ausgabe kann über STDOUT oder einen Funktionsrückgabewert erfolgen. Sie können keine eingebauten Funktionen verwenden, die dazu dienen, mehrzeilige Zeichenfolgen zu dedizieren oder genau diese Aufgabe auszuführen, z textwrap.dedent. B. Python's .

Das ist Code-Golf , also gewinnt die Lösung mit den wenigsten Bytes. Es gelten Standardlücken .

Testfälle

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

Zum Beispiel ist der letzte Testfall

   a   b
     c     d
    e f

und sollte so aussehen, nachdem führende Leerzeichen entfernt wurden:

a   b
  c     d
 e f

CJam, 20 bis 14 Bytes

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

Algorithmus :

• Wir teilen zuerst die Eingabe in Zeilenumbrüche und machen eine Kopie ( qN/_)
• Dann wird die kleinste Spalte mit einem Zeichen ohne Leerzeichen berechnet, indem das durch Zeilenumbrüche getrennte Array transponiert wird und dann einfach nach dem Index der ersten Zeile ohne Leerzeichen gesucht wird ( z{S-}#).
• Dann entfernen wir einfach so viele Zeichen aus jeder Zeile ( f>)
• Zum Schluss melden wir uns per newline wieder an ( N*)

Code-Erweiterung

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

Probieren Sie es hier online aus

Pyth, 19 18 17 14 Bytes

jbu>R!rhCG6G.z

Die Implementierung ist ziemlich cool.

1. u .zgreift nach allen stdin-Zeilen in einem Array und fügt sie ein G. Dann wertet es den inneren Körper aus, setzt das Ergebnis ein Gund tut dies so lange, bis es sich nicht mehr ändert (Fixpunkt).

2. !rhCG6transponiert G, ruft das erste Element des transponierten Arrays (die erste Spalte) ab, entfernt alle Leerzeichen und prüft, ob andere Zeichen als Leerzeichen übrig sind.

3. Der Wert von 2 ist ein Boolescher Wert, der als int 0 oder 1 angesehen werden kann. Er nimmt >R Gdiese Zahl und schneidet so viele Zeichen links von jeder Zeile in ab G. Die kombinierten Schritte 1, 2 und 3 bedeuten im Grunde, dass weiterhin Leerraumspalten entfernt werden, bis keine reine Leerraumspalte mehr vorhanden ist.

4. jb Verbindet das Zeilenfeld durch Zeilenumbrüche und druckt es aus.

sed - 26 Bytes

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

renn mit -rz

Ziemlich einfach:

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

-rOption aktiviert erweiterte reguläre Ausdrücke, -zliest die gesamte Eingabe als einzelne Zeichenfolge (verwendet tatsächlich NUL-Byte als Zeilentrennzeichen)

SWI-Prolog, 233 223 217 Bytes

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

Edit : Hat meine Antwort komplett geändert. Es werden jetzt Zeichencodes anstelle von Zeichenfolgen verwendet.

Ein Beispiel für diesen Aufruf wäre a(` a b\n c d\n e f`)., mit Anführungszeichen. Möglicherweise müssen "Sie stattdessen doppelte Anführungszeichen verwenden, wenn Sie einen alten SWI-Prolog-Distributor haben.

Julia, 93 92 81 Bytes

Dank Glen O 10 Bytes gespart.

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

Dadurch wird eine unbenannte Funktion erstellt, die eine Zeichenfolge akzeptiert und auf stdout druckt.

Ungolfed + Erklärung:

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

Weil es auffällig wenig Java gibt ...

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

Es sind nur Schleifen, die die Länge mit der zugeschnittenen Länge vergleichen und dann Teilstrings ausspucken. Nichts Besonderes. Für die Bildlaufleiste beeinträchtigt:

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

Vielen Dank an @ThisSuitIsBlackNot für den Vorschlag, die implizite Schleife von Perl zu verwenden

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

Das Obige wird als 30 Bytes für die Codezeile + 3 für 00pFlags gewertet .

Originalfassung, als Funktion:

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

Dies setzt das Argument in ein $_und versucht dann, gierig Leerzeichen, die in allen Zeilen vorhanden sind, mit /^( +).*(\n\1.*)*$/- abzugleichen. Wenn dies erfolgreich ist, $1enthält es jetzt das längste gemeinsame Präfix, und wir führen die Ersetzung aus s/^$1//mgr, um es am Anfang jeder Zeile zu löschen und den resultierenden String zurückzugeben.

Prüfung

$ 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

Dies kann mit ziemlicher Sicherheit noch etwas gekürzt werden, aber im Moment ist es nicht schlecht.

Danke an xnor für das Speichern von 4 Bytes!

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

C #, 18 + 145 = 163 Bytes

Benötigt (18 Bytes):

using System.Linq;

Methode (145 Bytes):

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

Die Methode berechnet die geringste Anzahl von führenden Leerzeichen in den Zeilen und erstellt eine neue Zeichenfolge, die aus allen Zeilen besteht, wobei N Zeichen übersprungen werden (wobei N die zuvor berechnete Zahl ist).

Ruby: 77 73 70 66 65 58 57 40 Zeichen

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

Probelauf:

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 #, 149 Bytes insgesamt

Praktisch die gleiche Lösung wie bei ProgramFOX, obwohl die Anzahl der zu trimmenden Zeichen manuell berechnet wird.

using System.Linq;

Und die Funktion selbst:

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 Bytes

In diesem Fall werden nur RegEx-Übereinstimmungen und -Ersetzungen verwendet.

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>

Wie immer nur Firefox, seit ES6. Fügt später die ES5-Version hinzu.

K, 31 Bytes

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

Übernimmt die Eingabe einer Liste von Zeichenfolgen und druckt das Ergebnis auf stdout.

Haskell, 52 Bytes

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

Anwendungsbeispiel: unlines.until(any(/=' ').map head)(map tail).lines $ " abc\n def\n ghi"->" abc\ndef\n ghi\n"

Wie es funktioniert:

                                           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

Lambda (94 Bytes):

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

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

Testdaten

s="\
   a   b
     c     d
    e f"

Antworten

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

Ausgabe

a   b
  c     d
 e f

R 118 111 Bytes

Verwenden der wunderbaren Zeichenfolgenfunktionen von R :) Dies ist ähnlich zu anderen bereits veröffentlichten Lösungen. Die Eingabe erfolgt über STDIN und Katzen an STDOUT.

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

Test und Erklärung

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

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

Ältere Lösung (57 Bytes):

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

Ursprüngliche Lösung (72 Bytes):

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

k (24 Bytes)

Nimmt eine Zeichenfolge als Argument und gibt eine Zeichenfolge zurück (mit nachfolgendem Zeilenumbruch).

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

Beispiel:

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 Bytes

|©ζ®gð*Ûζ»

Probieren Sie es online!

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

Beispielsweise...

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

Ausgabe...

a   b
  c     d
 e f

C GCC, 74 Bytes

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

Entfernt nur alle Leerzeichen, die sich nicht auf vorherige Zeilen beziehen, und fordert zum Beenden Hilfe an. Bedeutet AUCH in Bezug auf übliche Leerzeichen das OP, dass in welcher Zeile die wenigsten führenden Leerzeichen stehen, dh die Anzahl der Leerzeichen, die aus jeder Zeile entfernt werden sollen?

Gestapelt , nicht konkurrierend, 43 Bytes

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

Probieren Sie es online!

Dies funktioniert, indem Sie die Anzahl der Leerzeichen am Anfang jeder Zeile ermitteln ( '^ +'match$#'"!), das Minimum ermitteln, ein Leerzeichen so oft wiederholen und das Leerzeichen durch nichts in jeder Zeile ersetzen.

Vim, 33 , 31 Bytes

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

Probieren Sie es online!

Alte Version:

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

Stax , 9 Bytes

ü═≤+Σî║┘`

Führen Sie es aus und debuggen Sie es

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 Byte

Die Zeilenumbrüche sind notwendig und werden jeweils als 1 Byte gezählt:

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

Demo

Wie bei anderen ES6-Antworten funktionieren sie derzeit nur in 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 Byte

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

Die neuen Zeilen sind von Bedeutung

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

Rekursiv, wobei versucht wird, jeweils ein Leerzeichen aus jeder Zeile zu entfernen, bis ein Nicht-Leerzeichen gefunden wird.

Testen Sie das folgende Snippet - nur 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>