Python'da kodlama yaparken, bazen bir işlev içinde çok satırlı bir dize istersiniz, ör.

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

^{(Ters eğik çizgi, önde gelen bir yeni satırı kaldırmaktır)}

sAncak, gerçekten yazdırmaya çalışırsanız ,

    Line 1
    Line 2
    Line 3

Bizim istediğimiz bu değil! Çok fazla önde gelen boşluk var!

Meydan okuma

Yalnızca alfasayısal karakterler, boşluklar ve yeni satırlardan oluşan çok satırlı bir dize verildiğinde, her satırın başındaki tüm ortak boşlukları kaldırın. Her satırın en az bir boşluk olmayan karaktere sahip olması ve hiçbir boşluk içermemesi garanti edilir. Çıktının tamamı veya tek bir satır (ister isteğe bağlı tek bir son satırsonu hariç) olsun, ister çıktıdan önce veya sonra olsun, yabancı boşluklara sahip olmayabilir.

Giriş STDIN veya işlev bağımsız değişkeni üzerinden olabilir ve çıkış STDOUT veya işlev dönüş değeri üzerinden olabilir. Sen olamaz dedent satırlı dizeleri için tasarlanmıştır herhangi yerleşiklerini kullanabilir veya tam bu görevi, örneğin Python en gerçekleştirmek textwrap.dedent.

Bu kod golf , bu yüzden en az bayt içindeki çözüm kazanır. Standart boşluklar geçerlidir.

Test senaryoları

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

Örneğin, son test durumu

   a   b
     c     d
    e f

ve önde gelen alanları soyduktan sonra şöyle görünmelidir:

a   b
  c     d
 e f

CJam, 20 14 bayt

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

Algoritma :

• Öncelikle girişi yeni satırlara böleriz ve bir kopyasını alırız ( qN/_)
• Daha sonra, non boşluk karakteri ile en az kolon (birinci olmayan tüm alanı sıranın indeksi için ideal sonra sadece satır ayrılmış bir dizi aktarılması ve hesaplanır z{S-}#)
• Ardından, her bir satırdan o kadar çok karakteri kaldırırız ( f>)
• Son olarak, tekrar newline'a katılıyoruz ( N*)

Kod Genişletme

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

Buradan çevrimiçi deneyin

Pyth, 19 18 17 14 bayt

jbu>R!rhCG6G.z

Uygulama oldukça güzel.

1. u .zbir dizideki tüm stdin satırlarını yakalar, koyar G. Daha sonra iç bedeni değerlendirir, sonucu koyar ve Gartık değişmeyene kadar (sabit nokta) bunu yapmaya devam eder.

2. !rhCG6transpozisyonlar G, transpoze edilen dizinin ilk elemanını (ilk sütun) alır, boşluktan ayırır ve boşluk olmayan karakterlerin olup olmadığını kontrol eder.

3. 2'deki değer, int 0 veya 1 olarak görülebilen bir boolean değeridir. >R GBu sayıyı yakalar ve her satırın solundaki birçok karakteri dilimler G. Adım 1, 2 ve 3, temel olarak, beyaz boşluk sütunu kalmayıncaya kadar beyaz boşluk sütunlarını sıyırmaya devam edeceği anlamına gelir.

4. jb satır dizisini yeni satırlarla birleştirir ve yazdırır.

sed - 26 bayt

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

ile koş -rz

Oldukça basit:

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

-rseçeneği genişletilmiş normal ifadeleri açar, -ztüm girdiyi tek bir dize olarak okur (aslında satır sınırlayıcı olarak NUL bayt kullanır)

SWI-Prolog, 233 223 217 bayt

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

Düzenleme : Cevabımı tamamen değiştirdim. Artık dizeler yerine karakter kodları kullanıyor.

Bunu çağırmanın bir örneği, a(` a b\n c d\n e f`).backquotes ile olabilir. "Eski bir SWI-Prolog dağıtımınız varsa bunun yerine çift ​​tırnak kullanmanız gerekebilir .

Julia, 93 92 81 bayt

Glen O. sayesinde 10 bayt kurtardı

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

Bu, bir dizeyi kabul eden ve stdout'a yazdırılan adsız bir işlev oluşturur.

Ungolfed + açıklaması:

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

Çünkü göze çarpan Java eksikliği var ...

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

Sadece uzunluğu kesilmiş uzunlukla karşılaştıran, sonra alt dizeleri tüküren döngüler. Çok süslü bir şey yok. Kaydırma çubuğu bozulmuş olanlar için:

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

Perl'in örtülü döngüsünü kullanma önerisi için @ThisSuitIsBlackNot'a teşekkürler

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

Yukarıdaki 00pbayraklar için + 3 kod satırı için 30 bayt olarak puanlanır .

İşlev olarak orijinal sürüm:

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

Bu, argümanı $_ , daha sonra tüm satırlarda bulunan beyaz alanı açgözlü bir şekilde eşleştirmeye çalışır /^( +).*(\n\1.*)*$/- başarılı olursa, $1artık en uzun ortak öneki içerir ve s/^$1//mgrher satırın başından silmek ve sonuçta oluşan dizeyi döndürmek için değiştirme işlemini yürütürüz.

Ölçek

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

Python 2, 86 79 75 Bayt

Bu neredeyse kesinlikle biraz daha kısaltılabilir, ancak şu anda kötü değil.

4 bayt kaydettiği için xnor'a teşekkürler!

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

Yakut: 77 73 70 66 65 58 57 40 karakter

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

Örnek çalışma:

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 bayt

Gerektirir (18 bayt):

using System.Linq;

Yöntem (145 bayt):

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

Yöntem, satırlardaki en düşük satır aralığı sayısını hesaplar ve N karakterleri atlanarak (burada N , önceden hesaplanan sayıdır) tüm satırlardan oluşturulmuş yeni bir dize oluşturur .

C #, toplam 149 bayt

Kesilecek karakter sayısı manuel olarak hesaplanmasına rağmen, ProgramFOX'larla hemen hemen aynı çözüm.

using System.Linq;

Ve işlevin kendisi:

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 bayt

Bu tamamen RegEx eşleştirme ve yerine koyma kullanıyor.

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>

Her zaman olduğu gibi, sadece Firefox, ES6'dan beri. ES5 sürümünü daha sonra ekleyecek.

K, 31 bayt

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

Girdi dizelerin listesini alır ve sonucu stdout'a yazdırır.

Haskell, 52 bayt

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

Kullanım örneği: unlines.until(any(/=' ').map head)(map tail).lines $ " abc\n def\n ghi" ->" abc\ndef\n ghi\n"

Nasıl çalışır:

                                           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 bayt):

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

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

Test verisi

s="\
   a   b
     c     d
    e f"

Cevap

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

Çıktı

a   b
  c     d
 e f

R, 118111 bayt

R :) harika dize işlevlerini kullanma Bu zaten yayınlanan diğer çözümlere benzer / aynı. Giriş STDIN ve kediler STDOUT üzerinden yapılır.

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

Test ve açıklama

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

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

Eski çözüm (57 bayt):

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

Orijinal çözüm (72 bayt):

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

k (24 bayt)

Bir dizeyi bağımsız değişken olarak alır ve bir dizeyi döndürür (sondaki yeni satırla birlikte).

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

Misal:

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 bayt

|©ζ®gð*Ûζ»

Çevrimiçi deneyin!

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

Örneğin...

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

Çıktı...

a   b
  c     d
 e f

C GCC, 74 Bayt

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

Yalnızca önceki satırlarla ilgili olmayan, bitirmek için yardım isteyen tüm boşlukları kaldırır. AYRICA, ortak beyaz alanlar açısından, OP hangi satırın en az önde gelen boşluğa sahip olduğu, yani her bir çizgiden kaldırılacak boşlukların sayısı anlamına mı geliyor?

Yığılmış , rakipsiz, 43 bayt

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

Çevrimiçi deneyin!

Bu, her satırın başındaki boşluk sayısını () bularak, '^ +'match$#'"!minimum değeri alarak, birçok kez bir alanı tekrarlayarak ve bunu her satırdaki hiçbir şeyle değiştirerek çalışır.

Vim, 33 , 31 bayt

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

Çevrimiçi deneyin!

Eski versiyon:

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

Stax , 9 bayt

ü═≤+Σî║┘`

Çalıştır ve hata ayıkla

CoffeeScript, 112 bayt

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 bayt

Yeni satırlar zorunludur ve her biri 1 bayt olarak sayılır:

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

gösteri

Diğer ES6 yanıtlarında olduğu gibi, şu anda yalnızca Firefox'ta çalışıyorlar.

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 bayt

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

Yeni hatlar önemli

ES5 Demosu:

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

Yinelemeli, boşluk bulunmayana kadar her satırdan bir defada bir boşluk kaldırmaya çalışılıyor.

Aşağıdaki snippet'i çalıştırmayı test edin - ES6, yalnızca 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>