Entfernen Sie gemeinsame führende Leerzeichen

18

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 , 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
Sp3000
quelle
Darf die Ausgabe ein nachgestelltes Leerzeichen enthalten?
Orlp
@orlp Nein darf es nicht, wird klarstellen.
Sp3000,

Antworten:

12

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

Optimierer
quelle
8

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.

orlp
quelle
2
Können Sie dies bitte kurz erläutern? Das ist sehr komisch für mich!
Bobbel
2
@bobbel Erklärung hinzugefügt.
Orlp
Wirklich toll, danke! Davon habe ich noch nie gehört! Um dies online zu versuchen, fand ich: pyth.herokuapp.com/…
Bobbel
8

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)

Aragaer
quelle
Müssen Sie nicht gleich :;N;$!bzu Beginn die Eingabezeilen in einem einzigen Musterraum zusammenfassen? Bearbeiten: nein, tust du nicht; Dafür ist die -zFlagge da.
Toby Speight
Sie können dies zu Golf :;/^\S/M!s/^ //mg;t, jetzt nicht erforderlich-r
Kritixi Lithos vor
7

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.

Tödlich
quelle
5

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
Alex A.
quelle
Sie können Platz sparen, indem Sie nach dem ersten Nicht-Leerzeichen suchen, anstatt die Anzahl der Leerzeichen zu zählen. Anstatt zu minimum([length(search(j, r"^ +")) for j in p])+1verwenden minimum([search(j,r"[^ ]")[1]for j=p]). Da die Abfrage angibt, dass in allen Zeilen kein Leerzeichen verwendet wird, ist sie sicher und spart 9 Byte (einschließlich 3, die durch Verwendung von =anstelle von "in ). Still looking to see if more can be saved. (I wish I could drop the [1]" gespeichert wurden). Bei der Suche wird jedoch ein Enumerator-Array vom Typ "Any" erstellt, während dies mindestens erforderlich ist ein Int-Typ)
Glen O
Entschuldigen Sie den Fehler oben - anscheinend habe ich meine Bearbeitungen aufgebraucht - es sind nicht 9 Bytes, sondern 6, weil ich nicht bemerkt habe, dass Sie = in der Golf-Form verwendet haben. Wie auch immer, ich kann zwei weitere Zeichen speichern, indem ich p beim Starten der for-Schleife definiere:s->for i=(p=split(s,"\n")) println(i[minimum([search(j,r"[^ ]")[1]for j=p]):end])end
Glen O
OK, hier ist noch eine, die Sie ein bisschen mehr rasieren sollten - anstatt zu verwenden, minimum(x)wann xein Array vorliegt, verwenden Sie min(x...), um ein zusätzliches Byte zu sparen (ich werde dieses Byte zu meiner Liste der Julia-Golftipps hinzufügen).
Glen O
@ GlenO Schön, danke für die Vorschläge. Da Julia PCRE verwendet, können auch Nicht-Leerzeichen mit \Sanstatt verglichen werden [^ ], wodurch ein Byte gespeichert wird.
Alex A.
Hey, danke, dass \Sdu das erwähnt hast - ich bin nicht gut mit Regex, aber es stellte sich heraus, dass das auch für meine Lösung nützlich ist.
Glen O
4

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));
}
Geobits
quelle
4

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
Toby Speight
quelle
Sehr cool. Sie können einige Bytes abschneiden, indem Sie in der Befehlszeile Folgendes ausführen: perl -00pe '/^( +).*(\n\1.*)*$/&&s/^$1//mg'(30 Bytes + 3 für 00p).
ThisSuitIsBlackNot
/megeht weg, um aufzublicken -00p; Vielen Dank @ThisSuit
Toby Speight
3

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):]
Kade
quelle
1
Ein etwas kürzerer Weg, führende Leerzeichen zu zählen, ist x.find(x.strip()).
16.
@ xnor guten Anruf, danke! Ich habe von Ihnen den ganzen Tag für eine 60 - Byte - Lösung gewartet; P
Kade
input()in Python 2 würde diese Daten ersticken.
Steven Rumbalski
@StevenRumbalski, ich gehe davon aus, dass die Eingabe von Anführungszeichen umgeben ist. Früher habe ich der Bytezahl 2 hinzugefügt, um dies zu berücksichtigen, aber mehrere Personen haben gesagt, dass ich das nicht tun muss.
Kade
1
Dieses Programm ist traurig:):
HyperNeutrino
2

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

ProgramFOX
quelle
2

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
Mann bei der Arbeit
quelle
2
Wie wäre es f=->t{t.gsub /^#{t.scan(/^ */).min}/,""}?
Ventero,
Das ist großartig, @Ventero. Vielen Dank.
Manatwork
1

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)));}
Sok
quelle
@ProgramFOX Ich hatte Ihre Lösung erst gesehen, nachdem ich die Seite btw: o)
Sok
1

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])
Monopol
quelle
1

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.

Optimierer
quelle
1
Es scheint kürzer zu sein, ein Regular Expression-Literal als Zeichenfolge zu schreiben und es dann
auszuwerten
@ vihan1086 du könntest recht haben. Lass es mich versuchen.
Optimierer
1

K, 31 Bytes

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

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

kirbyfan64sos
quelle
1

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
nimi
quelle
1

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);
Die Krypta
quelle
1

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
Thor
quelle
2
Ein paar einfache Golf-Änderungen bringen dies auf 56 in meiner Zählung:cut -c$[`grep -o '^ *'<<<"$s"|sort|sed q|wc -c`]-<<<"$s"
Digital Trauma
1
@DigitalTrauma: Schön, ich habe das $[]Rechnen vergessen . Die cutSpaltenauswahl ist viel besser. Ich habe noch nie sed qeine Alternative gesehen head -n1, es ist ein guter Golftick. Vielen Dank!
Thor
2
In Bezug auf head -n1vs sed qgibt es ein lineTool im Paket util-linux.
Manatwork
@manatwork: Das spart ein Zeichen, ich werde es verwenden. Beachten Sie, dass es veraltet ist und in Zukunft möglicherweise nicht mehr zur Verfügung steht. Dies stammt aus der Datei deprecated.txt im Quellenbaum von util-linux: "Warum: Nutzlos, niemand verwendet diesen Befehl, head (1) ist besser".
Thor
1

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
> 
MickyT
quelle
Hey, herzlichen Glückwunsch zu 3k rep!
Alex A.
@AlexA. Prost, dachte nicht, dass es mir wichtig ist ... aber :)
MickyT
Sie meinen, Ihr Leben dreht sich nicht um gefälschte Internetpunkte? : P
Alex A.
@AlexA. Hoffentlich nicht :) Herzlichen Glückwunsch zu 6k
MickyT
1

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
Glen O
quelle
1

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
Skeevey
quelle
1

05AB1E , 10 Bytes

|©ζ®gð*Ûζ»

Probieren Sie es online!

Mr. Xcoder
quelle
Warten, * wiederholt die Zeichenfolge b einige Male? .. Wusste nicht über diese Funktion von *. Normalerweise mache ich das s∍(tauschen und verlängern), wenn ich einen bestimmten Charakter wiederholen möchte.
Kevin Cruijssen
Ja, das funktioniert in der Tat für Zeichenfolgen, vor allem, weil die Vektorisierung bei Zeichenfolgen keinen Sinn иergibt und eine Liste von Zeichen ergibt.
Mr. Xcoder
0

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
Rip Leeb
quelle
Nur kaum getestete Hinweise: Nicht erfassen /^( +)//^ +/(dann haben Sie den gewünschten Wert t[0]anstelle von t[1]); ändern s==""!s; Entfernen Sie das {und }um den Code nach if; entferne das ;vorher }; Verwenden der Gawk-spezifischen Funktion, um den {und }um den Code herum zu entfernen, nachdem for: {sub(s,"",z[r]);print z[r]}print gensub(s,"",1,z[r]).
Handarbeit
Tut mir leid, aber sowohl Ihr Originalcode als auch der mit meiner Größenoptimierung schlagen bei der Eingabe mit einer nicht eingerückten Zeile, die nicht die letzte ist, fehl. (Zum Beispiel "␠one \ nzero \ n␠one \ n␠␠two".)
manatwork
0

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?

Jake
quelle
Ja, die Zeile mit den wenigsten führenden Leerzeichen ist korrekt.
Sp3000,
0

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.

Conor O'Brien
quelle
0

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
DJMcMayhem
quelle
-1

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"
rink.attendant.6
quelle
-1

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>

rink.attendant.6
quelle
10
Es wäre großartig, wenn der Downvoter erklären könnte ...
rink.attendant.6
-1

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>

Downgoat
quelle
-1

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>

edc65
quelle