Ao codificar em Python, às vezes você deseja uma sequência multilinha dentro de uma função, por exemplo

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

^{(A barra invertida é para remover uma nova linha principal)}

Se você tentar realmente imprimir s, no entanto, receberá

    Line 1
    Line 2
    Line 3

Não é isso que queremos! Há muito espaço em branco à esquerda!

O desafio

Dada uma sequência multilinha composta apenas por caracteres alfanuméricos, espaços e novas linhas, remova todos os espaços comuns do início de cada linha. É garantido que cada linha tenha pelo menos um caractere que não seja de espaço e não terá espaços à direita. A saída pode não ter espaços em branco externos, seja antes ou depois de toda a saída ou de uma linha individual (com exceção de uma única nova linha de rastreamento opcional).

A entrada pode ser via STDIN ou argumento de função e a saída pode ser via STDOUT ou valor de retorno da função. Você não pode usar nenhum built-in projetado para deduzir cadeias de linhas múltiplas ou executar esta tarefa exata, por exemplo, do Python textwrap.dedent.

Isso é código-golfe , então a solução com o menor número de bytes vence. Aplicam-se brechas padrão .

Casos de teste

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

Por exemplo, o último caso de teste é

   a   b
     c     d
    e f

e deve ficar assim depois de remover os espaços à esquerda:

a   b
  c     d
 e f

CJam, 20 14 bytes

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

Algoritmo :

• Primeiro dividimos a entrada em novas linhas e tiramos uma cópia ( qN/_)
• Em seguida, a menor coluna com caractere não espacial é calculada transpondo a matriz separada por nova linha e procurando simplesmente o índice da primeira linha sem espaço ( z{S-}#)
• Em seguida, simplesmente removemos muitos caracteres de cada linha ( f>)
• Por fim, nos juntamos novamente à nova linha ( N*)

Expansão do código

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

Experimente online aqui

Pitão, 19 18 17 14 bytes

jbu>R!rhCG6G.z

A implementação é bem legal.

1. u .zpega todas as linhas de stdin em uma matriz, coloca-a G. Em seguida, avalia o corpo interno, coloca o resultado Ge continua fazendo isso até que não mais mude (ponto fixo).

2. !rhCG6transpõe G, obtém o primeiro elemento da matriz transposta (a primeira coluna), retira-o de qualquer espaço em branco e verifica se há algum caractere que não seja de espaço em branco.

3. O valor de 2 é um booleano, que pode ser visto como um int 0 ou 1. >R Gpega esse número e corta muitos caracteres à esquerda de cada linha G. As etapas 1, 2 e 3 combinadas basicamente significam que ele continuará removendo as colunas de espaço em branco até que não haja mais nenhuma coluna de espaço em branco puro.

4. jb une a matriz de linhas por novas linhas e a imprime.

sed - 26 bytes

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

correr com -rz

Bem direto:

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

-rA opção ativa regexps estendidos, -zlê toda a entrada como uma única sequência (na verdade, usa NUL-byte como delimitador de linha)

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 : Mudou completamente a minha resposta. Agora ele usa códigos de caracteres em vez de cadeias.

Um exemplo de chamar isso seria a(` a b\n c d\n e f`)., com aspas. Pode ser necessário usar aspas duplas, "se você tiver um distrib SWI-Prolog antigo.

Julia, 93 92 81 bytes

Economizou 10 bytes graças a Glen O.

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

Isso cria uma função sem nome que aceita uma string e imprime no stdout.

Ungolfed + explicação:

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

Porque há uma falta conspícua de 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));}

São apenas loops comparando comprimento com comprimento aparado e cuspindo substrings. Nada muito chique. Para os prejudicados na barra de rolagem:

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

Obrigado @ThisSuitIsBlackNot pela sugestão de usar o loop implícito do Perl

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

O acima é pontuado como 30 bytes para a linha de código + 3 para 00psinalizadores.

Versão original, como uma função:

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

Isso coloca o argumento em questão $_e tenta corresponder avidamente o espaço em branco que está presente em todas as linhas com /^( +).*(\n\1.*)*$/- se for bem-sucedido, $1agora contém o prefixo comum mais longo e executamos a substituição s/^$1//mgrpara excluí-lo do início de cada linha e retornar a sequência resultante.

Teste

$ 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

Definitivamente, isso pode ser encurtado um pouco mais, mas agora não é ruim.

Obrigado ao xnor por salvar 4 bytes!

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

Ruby: 77 73 70 66 65 58 57 40 caracteres

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

Exemplo de execução:

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 bytes

Requer (18 bytes):

using System.Linq;

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

O método calcula a menor quantidade de espaços iniciais nas linhas e cria uma nova sequência construída de todas as linhas, com N caracteres ignorados (onde N é o número calculado anteriormente).

C #, total de 149 bytes

Praticamente a mesma solução que os do ProgramFOX, embora o número de caracteres a serem cortados seja calculado manualmente.

using System.Linq;

E a própria função:

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

Este é totalmente usando apenas correspondência e substituições 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>

Como sempre, apenas o Firefox, desde o ES6. Adicionará a versão ES5 posteriormente.

K, 31 bytes

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

Pega na entrada uma lista de strings e imprime o resultado em stdout.

Haskell, 52 bytes

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

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

Como funciona:

                                           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

Dados de teste

s="\
   a   b
     c     d
    e f"

Responda

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

Resultado

a   b
  c     d
 e f

R, 118 111 bytes

Usando as maravilhosas funções de string do R :) Isso é semelhante / igual a outras soluções já publicadas. A entrada é através de STDIN e os gatos para STDOUT.

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

Teste e explicação

> 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

Solução mais antiga (57 bytes):

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

Solução original (72 bytes):

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

k (24 bytes)

Pega uma sequência como argumento e retorna uma sequência (com nova linha à direita).

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

Exemplo:

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

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

Por exemplo...

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

Resultado...

a   b
  c     d
 e f

C GCC, 74 bytes

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

Remove apenas todo o espaço em branco, não relacionado às linhas anteriores, solicitando ajuda para concluir. TAMBÉM, em termos de espaços em branco comuns, o OP significa que qual linha tem menos espaços à esquerda, ou seja, o número de espaços a serem removidos de cada linha?

Empilhados , não concorrentes, 43 bytes

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

Experimente online!

Isso funciona encontrando a quantidade de espaços no início de cada linha ( '^ +'match$#'"!), obtendo o mínimo, repita um espaço várias vezes e substituindo-o por nada em cada linha.

Vim, 33 , 31 bytes

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

Experimente online!

Versão antiga:

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

Stax , 9 bytes

ü═≤+Σî║┘`

Execute e depure

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 bytes

As novas linhas são necessárias e são contadas como 1 byte cada:

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

Demo

Assim como outras respostas do ES6, elas funcionam apenas no Firefox no momento.

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 bytes

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

As novas linhas são significativas

Demonstração 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

Recursivo, tentando remover um espaço de cada vez de cada linha até encontrar um não espaço.

Teste a execução do trecho abaixo - sendo ES6, apenas 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>