Já sabemos como tirar uma corda de seus espaços.

No entanto, como senhores / senhoras, deveríamos despi- lo.

Despir uma corda é o mesmo que removê-la, mas é mais delicado. Em vez de remover todos os espaços iniciais e finais de uma vez, nós os removemos um por um . Também alternamos entre à esquerda e à direita, para não queimar etapas.

Exemplo, começando com " codegolf "(cinco espaços à esquerda e à direita):

     codegolf     
    codegolf     
    codegolf    
   codegolf    
   codegolf   
  codegolf   
  codegolf  
 codegolf  
 codegolf 
codegolf 
codegolf

1. Primeiro, imprima a string inalterada. Em seguida, execute cada etapa. Comece removendo um espaço à esquerda (se aplicável - consulte a regra nº 2).

2. A entrada pode ter um número diferente de espaços iniciais e finais. Se você ficar sem espaço em um lado, continue despindo o outro até que a corda fique vazia.

3. A entrada pode não ter espaços à esquerda nem à direita. Se for esse o caso, produza como está.

4. Use os métodos de E / S padrão do PPCG . As brechas padrão do PPCG são proibidas.

5. O comportamento indefinido na entrada vazia, ou entrada que contém apenas espaços, está OK.

6. Você pode assumir que a sequência conterá apenas caracteres do espaço imprimível ASCII ( 0x20para 0x7E).

Exemplos - os espaços são substituídos por pontos .para melhor legibilidade:

4 leading spaces, 5 trailing: "....Yes, Sir!....."
....Yes, Sir!.....
...Yes, Sir!.....
...Yes, Sir!....
..Yes, Sir!....
..Yes, Sir!...
.Yes, Sir!...
.Yes, Sir!..
Yes, Sir!..
Yes, Sir!.
Yes, Sir!

6 leading, 3 trailing: "......Let's go golfing..."
......Let's go golfing...
.....Let's go golfing...
.....Let's go golfing..
....Let's go golfing..
....Let's go golfing.
...Let's go golfing.
...Let's go golfing
..Let's go golfing
.Let's go golfing
Let's go golfing

0 leading, 2 trailing: "Hello.."
Hello..
Hello.
Hello

0 leading, 0 trailing: "World"
World

21 leading, 5 trailing: ".....................a....."
.....................a.....
....................a.....
....................a....
...................a....
...................a...
..................a...
..................a..
.................a..
.................a.
................a.
................a
...............a
..............a
.............a
............a
...........a
..........a
.........a
........a
.......a
......a
.....a
....a
...a
..a
.a
a

Um cavalheiro / dama é conciso, por isso vence a resposta mais curta em bytes .

Retina , 26 bytes

{m`^ (.+)\z
$&¶$1
 $
 ¶$%`

Experimente online! (O conjunto de testes usa períodos para maior clareza. O rodapé e o cabeçalho os convertem para e de espaços para o código principal.)

Explicação

Seria bom se pudéssemos alternar entre soltar um espaço à esquerda e um à direita e imprimir o resultado intermediário a cada vez. O problema é que atualmente o Retina não pode imprimir condicionalmente; portanto, ele imprimiria esse resultado intermediário se não sobrar espaço à esquerda ou à direita, gerando duplicatas. (O Retina 1.0 terá uma opção que somente imprime o resultado se a string foi alterada pela operação, mas ainda não estamos lá ...)

Então, em vez disso, estamos construindo uma única sequência contendo todos os resultados intermediários e imprimindo isso no final.

{m`^ (.+)\z
$&¶$1

Ele {agrupa os dois estágios do programa em um loop que se repete até que a string pare de mudar (o que significa que não há espaços à esquerda / à direita). O palco em si corresponde a um espaço à esquerda na linha final da string e à linha final e, em seguida, grava de volta a correspondência, bem como as coisas após o espaço em uma nova linha (eliminando, assim, o espaço à esquerda na cópia).

 $
 ¶$%`

Remover o espaço à direita é um pouco mais fácil. Se apenas correspondermos ao espaço final, podemos acessar as coisas à sua frente (na mesma linha) com as $%`quais há uma variante com reconhecimento de linha da substituição do prefixo $`.

Python 2 , 122 107 103 102 98 95 93 91 90 88 87 bytes

s=input()+' '
a=0
while-a*s!=id:
 if a:id=s
 a=~a
 if'!'>s[a]:s=s[1+a:len(s)+a];print s

Experimente online!

Python 3 , 97 95 93 90 bytes

s=input()
a=p=print
p(s)
while s!=a:
 a=s
 if'!'>s:s=s[1:];p(s)
 if'!'>s[-1]:s=s[:-1];p(s)

Experimente online!

Perl 6 , 55 bytes

Guardado 3 bytes graças a @nwellnhof.

{($_,{$++%2??S/" "$//!!S/^" "//}...*)[^.comb*2].unique}

Experimente online!

Explicação : ($_,{$++%2??S/" "$//!!S/^" "//}...*)é uma sequência infinita recursiva que começa com a sequência original ( $_) e o próximo elemento é fornecido pelo bloco chamado no elemento anterior.

O próprio bloco obtém a string na $_variável. O operador S/(regex)/(string)/pesquisará a primeira ocorrência de (regex)in $_, substitui-a por (string)e retorna o resultado. Se não houver correspondência, ele retornará o conteúdo de $_inalterado. Usamos o operador ternário ?? !!com a condição $++%2, que alterna entre Falsee True( $é uma variável livre que conserva seu conteúdo nas chamadas para o bloco).

Na pior das hipóteses (todos os espaços de um lado e 1 outro caractere), removemos 1 espaço a cada 2 etapas. Portanto, podemos ter certeza de que em 2 * (comprimento da cadeia) etapas, todos os espaços serão removidos. Pegamos muitos elementos da sequência recursiva com [^.comb*2]e finalmente descartamos duplicatas (que ocorrem sempre que um espaço deveria ter sido removido, mas não existe) com .unique. Isso retorna a lista de cadeias, progressivamente removidas de espaços.

05AB1E , 21 15 bytes

=v¬ðQi¦=}¤ðQi¨=

Experimente online!

Explicação ^

=                 # print input
 v                # for each character in input
  ¬ðQi  }         # if the first char in the current string is a space
      ¦=          # remove it and print without popping
         ¤ðQi     # if the last char in the current string is a space
             ¨=   # remove it and print without popping

C (gcc) , 89 84 bytes

A versão recursiva é mais curta ;-)

j;f(char*s){puts(s);*s^32||puts(++s);s[j=strlen(s)-1]<33?s[j]=0,f(s):*s^32||f(s+1);}

Experimente online!

C (gcc) , 107 102 101 100 99 bytes

Economizou 2 bytes graças a @Jonathan Frech usando espaços e ~

i,j,k;f(char*s){for(i=~++k,puts(s);i^k;k=s[j=strlen(s)-1]<33?s[j]=0,puts(s):0)*s^32?i=0:puts(++s);}

Experimente online!

JavaScript (ES6) 92

@Upvoters: dê uma olhada nas outras respostas JS abaixo, com 76 bytes de comprimento

(s,q,l=2,p=0)=>{for(alert(s);l--;p=!p)s[+p&&s.length-p]<'!'&&alert(s=s.slice(!p,-p||q,l=2))}

Um loop procurando um espaço na frente ou no final. Se encontrado, remova o espaço e a sequência de saída. Se nenhum espaço for encontrado 2 vezes, pare.

F=
(s,q,l=2,p=0)=>{for(alert(s);l--;p=!p)s[+p&&s.length-p]<'!'&&alert(s=s.slice(!p,-p||q,l=2))}

// some trick to show dots instead of spaces, for test
alert=x=>console.log(x
  .replace(/^ +/g,z=>'.'.repeat(z.length))
  .replace(/ +$/g,z=>'.'.repeat(z.length))
)

function go() {F(I.value.replace(/\./g,' '))}

go()

<input ID=I value='....yes Sir!....'> (use dot instead of space)
<button onclick='go()'>Go</button>

Perl 5, 32 bytes

Guardado 4 bytes devido a @Abigail .

1while s/^ /!say/e+s/ $/!say/e

Requer -plcontado como 2, invocado com -E.

Uso da amostra

$ echo '   test   ' | perl -plE'1while s/^ /!say/e+s/ $/!say/e'
   test   
  test   
  test  
 test  
 test 
test 
test

Experimente online!

C # (.NET Core) , 192 183 182 181 179 178 bytes

^{-3 bytes graças a Kevin Cruijssen}

n=>{var o=n+"\n";for(var e=1;n.Trim()!=n;){if(1>(e^=1))if(n[0]<33)n=n.Remove(0,1);else continue;else if(n.TrimEnd()!=n)n=n.Remove(n.Length-1);else continue;o+=n+"\n";};return o;}

Experimente online!

Java 8, 150 146 145 137 bytes

s->{String r=s;for(int f=0;s!=s.trim();f^=1)r+="\n"+(s=f+s.charAt(0)<33|!s.endsWith(" ")?s.substring(1):s.replaceAll(" $",""));return r;}

-4 bytes graças a @Nevay mudando (f<1&s.charAt(0)<33)para f+s.charAt(0)<33.
-1 byte usando o !s.trim().equals(s)truque da resposta C # .NET de @someone em vez de s.matches(" .*|.* ").
-8 bytes graças a @Nevay novamente, alterando !s.trim().equals(s)para s!=s.trim(), porque String#trimretornará " Uma cópia dessa sequência com o espaço em branco à esquerda e à direita removido, ou essa sequência se não tiver espaço em branco à esquerda ou à direita ", portanto, a referência permanece a mesma e !=pode ser usado para verificar se eles são a mesma referência, em vez de .equalsverificar o mesmo valor.

Explicação:

Experimente aqui (ou tente uma versão mais visual aqui, em #vez de espaços).

s->{                               // Method with String as both parameter and return-type
  String r=s;                      //  Result-String (starting at the input)
  for(int f=0;                     //  Flag-integer (starting at 0)
      s!=s.trim();                 //  Loop as long as `s` contains leading/trailing spaces
      f^=1)                        //    And XOR(1) `f` after every iteration (0->1; 1->0)
    r+="\n"                        //   Append the result with a new-line
       +(                          //    Followed by:
         s=f+                      //     If `f` is 0,
             s.charAt(0)<33        //     and `s` starts with a space
           |!s.endsWith(" ")?      //     Or doesn't end with a space
            s.substring(1)         //      Remove the first leading space
           :                       //     Else:
            s.replaceAll(" $",""));//      Remove the last trailing space
                                   //  End of loop (implicit / single-line body)
  return r;                        //  Return the result-String
}                                  // End of method

C, 91 90 bytes

i,l;f(char*s){for(i=puts(s);i;i=(s[l=strlen(s)-1]*=s[l]>32)?i:puts(s))i=*s<33&&puts(++s);}

Experimente online!

Gelatina , 16 bytes

Ḋ=⁶Ḣ$¡UµÐĿ¹Ṛƭ€QY

Experimente online!

-2 bytes graças a Erik the Outgolfer
-1 byte graças a milhas

Explicação

Ḋ=⁶Ḣ$¡UµÐĿ¹Ṛƭ€QY  Main link
       µÐĿ        While the results are unique (collecting intermediate results), apply the last link (`µ` creates a new monadic link):
Ḋ=⁶Ḣ$¡            Remove a space from the beginning if there is one
 =⁶Ḣ$             If the first character is a space, then 1, else 0
 =                Compare each character to
  ⁶               ' '
   Ḣ              Get the first comparison
Ḋ                 Then Dequeue the string (s -> s[1:])
    ¡             That many times
     U            And reverse the string (the next time this is called, it will remove spaces from the end instead)
             €    For each string
            ƭ     Alternate between two commands:
          ¹       Identity (do nothing), and
           Ṛ      Reverse
          ¹Ṛƭ€    Correct all strings that are reversed to remove the trailing space
              Q   Remove duplicates (where there was no space to remove)
               Y  Join on newlines

Ruby , 63 bytes

->s{*x=s;(s=~/^ /&&x<<s=$';s=~/ $/&&x<<s=$`)while s=~/^ | $/;x}

Experimente online!

Java (OpenJDK 8) , 161 147 146 bytes

x->{for(int l=0,r=x.length(),k=-1,u,v;((u=32-x.charAt(l)>>k)*(v=32-x.charAt(r-1)>>-1))<1;x+="\n"+x.substring(l-=k&~u|v,r+=(k=~k)&~v|u));return x;}

Experimente online!

-1 byte graças a @Kevin Cruijssen !

x -> {
    /*
     * l: left index (inclusive)
     * r: right index (exclusive)
     * k: side to remove from, -1:=left, 0:=right
     * u: left character   0:=space, <0:=no space (-1 if k is left side)
     * v: right character  0:=space, -1:=no space
     */
    for (int l = 0, r = x.length(), k = -1, u, v;
            ((u = 32 - x.charAt(l) >> k)
           * (v = 32 - x.charAt(r - 1) >> -1)) < 1; // loop while left or right has space(s)
            x += "\n" + x.substring(                // append newline and substring
                    l -= k & ~u | v,                // inc. left  if k is left side
                                                    //               and left has space
                                                    //            or right has no space
                    r += (k = ~k) & ~v | u));       // dec. right if k is right side
                                                    //               and right has space
                                                    //            or left has no space
    return x;
}

05AB1E , 25 17 bytes

-8 bytes, emprestando a idéia de não necessidade de verificação final da Emigna

,v2F¬ðQi¦DNiR},}R

Experimente online!

Tenho certeza de que uma abordagem menos direta pode superar essa solução facilmente. Para agora...

Explicações:

,v2F¬ðQi¦DNiR},}R           Full Programm
,                           Print the input string
 v                          For each char of the string
                               (we don't really care, we only need to loop
                                enough times to accomplish our task, since
                                we print conditionally we can loop more
                                times than necessary)
  2F...........}            Two times...
    ¬õQi                       Is 1st item a space?
        ¦D                        Remove 1st item + duplicate
          NiR}                    If on the second pass: reverse the list
              ,                   Pop & print with newline
               }               End If
                 R          Reverse the list

R , 145 133 111 bytes

-12 bytes graças a @ Giuseppe, armazenando o resultado de subuma nova variável e testando se ela foi alterada

-22 bytes retornando um vetor de cadeias em vez de uma cadeia com novas linhas

function(s){L=s
while(grepl("^ | $",s)){if((x=sub("^ ","",s))!=s)L=c(L,x)
if((s=sub(" $","",x))!=x)L=c(L,s)}
L}

Experimente online!

Explicação sobre uma versão parcialmente não destruída:

function(s){
  L=s                          # Initialise a vector with the original string
  while(grepl("^ | $",s)){     # While there are leading or trailing spaces...
    if((x=sub("^ ","",s))!=s){ # Check whether we can remove a leading space
      L=c(L,x)                 # If so, add the shortened string to the vector
    }
    if((s=sub(" $","",x))!=x){ # Check whether we can remove a trailing space
      L=c(L,x)                 # If so, add the shortened string to the vector
    }
  }
  L                            # Return the vector
}                              

Java (OpenJDK 8) , 137 125 121 120 124 bytes

s->{int i=1;do System.out.println(s);while(s!=(s=s.substring(s.charAt(0)<33?i:(i=0),s.length()-(s.endsWith(" ")?i^=1:0))));}

Experimente online!

MATL , 21 16 bytes

tnE:"t@o&)w46-?x

Isso usa pontos em vez de espaços para maior clareza. Para espaços, substitua 46por 32.

Experimente online!

Explicação

tn      % Input (implicit). Duplicate and push length, say L
E       % Multiply by 2
:       % Push range [1 2 ... 2*L]
"       % For each k in that array
  t     %   Duplicate the string at the top of the stack
  @     %   Push k
  o     %   Parity: gives 1 or 0
  &)    %   Two-ouput indexing. Pushes the k-th entry of the string and then
        %   the rest of the string. The 1-st output is the first, the 0-th
        %   is the last (indexing is 1-based dand modular)
  w     %   Swap
  46-   %   Subtract 46, which ias ACII for '.'
  ?     %   If non-zero
    x   %     Delete sub-string that was obained by removing that entry
        %   End (implicit)
        % End (implicit)
        % Display stack (implicit)

Casca , 23 22 bytes

u§↑L`G`I¢e₁ȯ↔₁↔
?tI<"!

Agradecimentos a Leo por -1 byte.

Experimente online!

Explicação

A função `G`Ideve realmente ser um recurso interno ...

?tI<"!  Helper function: remove initial space.
?  <"!  If less than the string "!",
 t      remove first character,
  I     else return as is.
u§↑L`G`I¢e₁ȯ↔₁↔  Main function.
         e       List containing
          ₁      the helper function
           ȯ↔₁↔  and the composition reverse-helper-reverse.
        ¢        Repeat it cyclically.
    `G`I         Cumulative reduce from left by function application
                 using input string as initial value.
 §↑L             Take first length(input) values.
u                Remove duplicates.

C ++, 196 193 189 186 183 bytes

-10 bytes graças a Jonathan Frech
-3 bytes graças a Zacharý

#include<iostream>
#include<string>
#define D std::cout<<s<<'\n'
#define R ~-s.size()
auto u=[](auto s){D;while(s[0]<33||s[R]<33){if(s[0]<33)s.erase(0,1),D;if(s[R]<33)s.erase(R),D;}};

A compilação com MSVC requer a desativação de verificações SDL

C # (.NET Core) , 176 170 bytes

using System;s=>{Action o=()=>Console.WriteLine(s);o();Func<int>l=()=>s.Length-1;while(s!=s.Trim()){if(s[0]<33){s=s.Remove(0,1);o();}if(s[l()]<33){s=s.Remove(l());o();}}}

Experimente online!

Essa é uma alternativa à resposta de alguém , e apenas gera as strings diretamente.

JavaScript (ES6), 76 bytes

f=(s,r,n,l=s.length)=>s[r?--l:0]<"!"?s+`
`+f(s.slice(!r,l),!r):n?s:f(s,!r,1)

Saídas como uma sequência multilinha.

Casos de teste

Usando pontos em vez de espaços, como a maioria das respostas.

f=(s,r,n,l=s.length)=>s[r?--l:0]<"!"?s+`
`+f(s.slice(!r,l),!r):n?s:f(s,!r,1)

// converting to and from dots and spaces
let dots=s=>s.replace(/^\.+|\.+$/gm,x=>" ".repeat(x.length));
let spaces=s=>s.replace(/^ +| +$/gm,x=>".".repeat(x.length));

["....Yes, Sir!.....", "......Let's go golfing...", "Hello..", "World", ".....................a....."]
.forEach(test=>O.innerHTML+=spaces( f(dots(test)) ) + "\n\n");

<pre id=O></pre>

Sed, 24 bytes

p;:s s/ //p;s/ $//p;ts;D

Experimente Online!

Oitava , 88 83 bytes

5 bytes de desconto graças a Stewie Griffin!

x=[input('') 0];for p=mod(1:sum(x),2)if x(~p+end*p)<33,disp(x=x(2-p:end-p)),end,end

Experimente online!

código de máquina x86 para Linux, 60 bytes

e8 1f 00 00 00 31 c0 80 3f 20 75 09 47 4d 74 10
e8 0f 00 00 00 80 7c 2f ff 20 74 05 84 c0 75 e5
c3 4d eb dc 6a 04 58 50 31 db 43 89 f9 89 ea cd
80 58 6a 0a 89 e1 89 da cd 80 58 c3

Esta é uma função para Linux x86. Leva como ponteiro de entrada para a string edie o comprimento da string ebp.

Ungolfed, com alguma infraestrutura para testar (compile com o FASM, execute a string como argumento do programa; procure um undress:rótulo para o código de função real):

format ELF executable
segment executable
SYS_WRITE = 4
    jmp     callUndress
; -------------------- the function itself --------------------------------
; Input:
;   edi=string
;   ebp=length
undress:
undressLoopPrint:
    call    print
undressLoop:
    xor     eax, eax    ; flag of having printed anything on this iteration
    cmp     byte [edi], ' '
    jne     startsWithoutSpace
    inc     edi
    dec     ebp
    jz      quit
    call    print
startsWithoutSpace:
    cmp     byte [edi+ebp-1], ' '
    je      endsWithSpace
    test    al, al      ; if print has been called, then we have 0x0a in eax
    jnz     undressLoop
quit:
    ret
endsWithSpace:
    dec     ebp
    jmp     undressLoopPrint
print:
    push    SYS_WRITE
    pop     eax
    push    eax
    xor     ebx, ebx
    inc     ebx ; STDOUT
    mov     ecx, edi
    mov     edx, ebp
    int     0x80
    pop     eax
    push    0x0a    ; will print newline
    mov     ecx, esp
    mov     edx, ebx ; STDOUT=1, which coincides with the length of newline
    int     0x80
    pop     eax
    ret
; --------------------- end undress ---------------------------------------
SYS_EXIT = 1
STDERR = 2
callUndress:
    pop     eax     ; argc
    cmp     eax, 2
    jne     badArgc
    pop     eax     ; argv[0]
    pop     edi
    mov     al, 0
    cld
    mov     ecx, -1
    repne   scasb
    lea     edi, [edi+ecx+1] ; argv[1]
    neg     ecx
    sub     ecx, 2
    mov     ebp, ecx     ; strlen(argv[1])
    call    undress
    xor     ebx, ebx
exit:
    mov     eax, SYS_EXIT
    int     0x80
    ud2
badArgc:
    mov     esi, eax
    mov     eax, SYS_WRITE
    mov     ebx, STDERR
    mov     ecx, badArgcMsg
    mov     edx, badArgcMsgLen
    int     0x80
    mov     ebx, esi
    neg     ebx
    jmp     exit
badArgcMsg:
    db      "Usage: undress YourString",0x0a,0
badArgcMsgLen = $-badArgcMsg
segment readable writable
string:
    db      100 dup(0)
    stringLen = $-string

PHP , 117 bytes

Eu adiciono um espaço extra no início para que ele ocupe o espaço e mostre o original sem nenhum código extra.

Meio novo nisso ... o <? Php e o espaço no início do arquivo PHP adicionariam 6 bytes extras ou eu o recebo de graça?

$s=" $argn";while($r!=$s){$r=$s;if($s[0]==" ")echo($s=substr($s,1))."
";if($s[-1]==" ")echo($s=substr($s,0,-1))."
";}

Experimente online!

Pitão , 28 bytes

QW<lrKQ6lQ=hZ?&%Z2qdhQ=tQ=PQ

Experimente aqui! ou Verifique todos os casos de teste!

Explicação

QW<lrKQ6lQ=hZ?&%Z2qdhQ=tQ=PQ   ~ Full program. Q is autoinitialized to input.

Q                              ~ Output the input.
 W<lrKQ6lQ                     ~ Loop while the condition is met.
  <                            ~ Is smaller?
   lrKQ6                       ~ The length of the original input, stripped on both sides.
        lQ                     ~ The length of the current Q.
          =hZ                  ~ Increment a variable Z, initially 0
             ?&%Z2qdhQ         ~ If Z % 2 == 1 and Q[0] == " ", then:
                      =tQ      ~ Make Q equal to Q[1:] and output, else:
                         =PQ   ~ Make Q equal to Q[:-1] and output.

Python 2 , 79 bytes

-1 byte graças a @JonathanFrech

f=lambda s,i=1:[s]+(s>i*'!'and'!'>s[-1]and f(s[:-1])or'!'>s and f(s[1:],0)or[])

Experimente online!

O traje de teste substitui "."por " "antes de chamar a função e " "volta a "."antes de imprimir os resultados para maior clareza.

C # - mais uma vez, 125 bytes

while(s.Trim()!=s){if(s[0]==' '){yield return s=s.Substring(1);}if(s.Last()==' '){yield return s=s.Substring(0,s.Length-1);}}

Felicidades!

Experimente online!

Oitava , 89 bytes

s=input('');while any(s([1,end])<33)if s(1)<33,s(1)=[],end,if s(end)<33,s(end)=[],end,end

Experimente online!

Acrescentarei uma explicação mais tarde, quando tiver tempo. Talvez eu consiga tirar alguns bytes de golfe se mudar completamente a abordagem, mas não vejo como é infelizmente.

As últimas letras aqui explicitam: "envia endendendend". Eu gostaria que houvesse uma maneira de armazenar endcomo uma variável e usá-la, mas adivinhem ...

Bater, 98 94 bytes

4 bytes salvos usando subshell em vez de sequências (desempenhos ruins)

r()(s=$1;[[ $s = $b ]]||([[ $s = $a ]]||echo "$s"
b=$a a=$s;((i=!i))&&r "${s# }"||r "${s% }"))

Primeira resposta

r(){ s=$1;[[ $s = $b ]]||{ [[ $s = $a ]]||echo "$s"
b=$a a=$s;((i=!i))&&r "${s# }"||r "${s% }";};}

Observe que o !escape deve ser feito no modo interativo