Już teraz wiemy, jak usunąć sznurek z jego przestrzeni.

Jednak jako właściwi panowie / panie powinniśmy raczej to rozebrać .

Rozebranie sznurka jest równoznaczne z rozebraniem go, tylko delikatniejsze. Zamiast usuwać wszystkie początkowe i końcowe spacje na raz, usuwamy je jeden po drugim . Zmieniamy też naprzemiennie na wiodące i końcowe, aby nie palić kroków.

Przykład, zaczynając od " codegolf "(pięć początkowych i końcowych spacji):

     codegolf     
    codegolf     
    codegolf    
   codegolf    
   codegolf   
  codegolf   
  codegolf  
 codegolf  
 codegolf 
codegolf 
codegolf

1. Najpierw wyjście niezmienione. Następnie wypisz każdy krok. Zacznij od usunięcia wiodącej spacji (jeśli dotyczy - patrz reguła # 2).

2. Dane wejściowe mogą mieć inną liczbę początkowych i końcowych spacji. Jeśli zabraknie Ci miejsca po jednej stronie, rozbierasz się po drugiej, aż sznurek będzie pusty.

3. Dane wejściowe mogą nie mieć spacji początkowych ani końcowych. W takim przypadku wyślij go takim, jakim jest.

4. Użyj domyślnych metod We / Wy PPCG . PPCG Domyślne luki są zabronione.

5. Niezdefiniowane zachowanie przy pustych danych wejściowych lub danych zawierających tylko spacje jest OK.

6. Możesz założyć, że ciąg będzie zawierał tylko znaki z przestrzeni drukowalnej ASCII ( 0x20do 0x7E).

Przykłady - spacje są zastępowane kropkami .dla lepszej czytelności:

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

Dżentelmen / dama jest zwięzły, więc wygrywa najkrótsza odpowiedź w bajtach .

Siatkówka , 26 bajtów

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

Wypróbuj online! (Pakiet testowy używa okresów dla zachowania przejrzystości. Stopka i nagłówek konwertują je na spacje i od spacji dla kodu głównego).

Wyjaśnienie

Byłoby miło, gdybyśmy mogli po prostu naprzemiennie upuszczać miejsce na początku i na końcu i drukować wynik pośredni za każdym razem. Problem polega na tym, że obecnie Retina nie może drukować warunkowo, więc wydrukowałby nawet ten wynik pośredni, jeśli nie pozostałyby żadne początkowe lub końcowe spacje, generując duplikaty. (Retina 1.0 otrzyma opcję, która drukuje wynik tylko wtedy, gdy łańcuch został zmieniony przez operację, ale jeszcze nas nie ma ...)

Zamiast tego tworzymy pojedynczy ciąg zawierający wszystkie wyniki pośrednie i drukujemy to na końcu.

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

{Owija obu etapów programu, w pętli, która powtarza się, aż przestanie się zmieniać ciąg (które pozostały oznacza, że nie są prowadzące / spacje). Sam etap dopasowuje spację wiodącą w ostatnim wierszu łańcucha i tej ostatniej linii, a następnie zapisuje dopasowanie, a także elementy po spacji w nowej linii (upuszczając w ten sposób spację wiodącą w kopii).

 $
 ¶$%`

Usunięcie końcowej spacji jest nieco łatwiejsze. Jeśli po prostu dopasujemy ostatnią spację, możemy uzyskać dostęp do rzeczy przed nią (w tym samym wierszu), z $%`którymi jest zależny od linii wariant podstawiania prefiksu $`.

Python 2 , 122 107 103 102 98 95 93 91 90 88 87 bajtów

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

Wypróbuj online!

Python 3 , 97 95 93 90 bajtów

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)

Wypróbuj online!

Perl 6 , 55 bajtów

Zaoszczędź 3 bajty dzięki @nwellnhof.

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

Wypróbuj online!

Objaśnienie : ($_,{$++%2??S/" "$//!!S/^" "//}...*)to rekurencyjna nieskończona sekwencja, która zaczyna się od oryginalnego ciągu ( $_), a następny element jest podawany przez blok wywołany na poprzednim elemencie.

Sam blok dostaje ciąg znaków do $_zmiennej. Operator S/(regex)/(string)/wyszuka pierwsze wystąpienie (regex)in $_, zamieni je na (string)i zwróci wynik. Jeśli nie ma dopasowania, zwraca zawartość $_niezmienionej. Używamy operatora trójskładnikowego ?? !!z warunkiem $++%2, który zmienia się na przemian Falsei True( $jest to zmienna bezpłatna, która zachowuje swoją zawartość podczas wywołań bloku).

W najgorszym przypadku (wszystkie spacje po jednej stronie i 1 inna postać) usuwamy 1 spację co 2 kroki. Możemy więc być pewni, że w krokach 2 * (długość ciągu) wszystkie spacje zostaną usunięte. Bierzemy tyle elementów z sekwencji rekurencyjnej [^.comb*2]i ostatecznie odrzucamy duplikaty (które pojawiają się, gdy miejsce powinno zostać usunięte, ale go nie ma) .unique. Zwraca listę ciągów znaków, stopniowo usuwanych ze spacji.

05AB1E , 21 15 bajtów

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

Wypróbuj online!

Wyjaśnienie ^

=                 # 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 bajtów

Wersja rekurencyjna jest krótsza ;-)

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

Wypróbuj online!

C (gcc) , 107 102 101 100 99 bajtów

Zaoszczędzono 2 bajty dzięki @Jonathan Frech używającej spacji i ~

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

Wypróbuj online!

JavaScript (ES6) 92

@Upvoters: spójrz na drugą odpowiedź JS poniżej o długości 76 bajtów

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

Pętla szukająca miejsca z przodu lub na końcu. Jeśli znaleziono, usuń spację i ciąg wyjściowy. Jeśli 2 razy nie znaleziono miejsca, zatrzymaj się.

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 bajty

Zapisano 4 bajty dzięki @Abigail .

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

Wymaga -plliczony jako 2, wywoływany z -E.

Przykładowe użycie

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

Wypróbuj online!

C # (.NET Core) , 192 183 182 181 179 178 bajtów

^{-3 bajty dzięki 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;}

Wypróbuj online!

Java 8, 150 146 145 137 bajtów

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 bajty dzięki zmianie @Nevay(f<1&s.charAt(0)<33) na f+s.charAt(0)<33.
-1 bajt przy użyciu lewy!s.trim().equals(s) z odpowiedzi C # .NET firmy @someone zamiast s.matches(" .*|.* ").
-8 bajtów dzięki @Nevay ponownie, zmieniając !s.trim().equals(s)na s!=s.trim(), ponieważ String#trimzwróci „ Kopię tego ciągu z usuniętymi początkowymi i końcowymi białymi spacjami lub ten ciąg, jeśli nie ma wiodących ani końcowych białych spacji ”, dlatego odniesienie pozostaje takie samo i !=można użyć do sprawdzenia, czy są one tym samym odwołaniem, zamiast .equalsdo sprawdzenia tej samej wartości.

Wyjaśnienie:

Wypróbuj go tutaj (lub wypróbować wersję bardziej wizualny tutaj ze #zamiast spacji).

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 bajtów

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

Wypróbuj online!

Galaretka , 16 bajtów

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

Wypróbuj online!

-2 bajty dzięki Erikowi Outgolfer
-1 bajt dzięki milom

Wyjaśnienie

Ḋ=⁶Ḣ$¡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

Rubinowy , 63 bajty

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

Wypróbuj online!

Java (OpenJDK 8) , 161 147 146 bajtów

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

Wypróbuj online!

-1 bajt dzięki @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 bajtów

-8 bajtów, pożyczając od Emigny pomysł niepotrzebnego sprawdzania końca

,v2F¬ðQi¦DNiR},}R

Wypróbuj online!

Jestem pewien, że mniej proste podejście może łatwo pokonać to rozwiązanie. Na razie...

Objaśnienia:

,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 bajtów

-12 bajtów dzięki @Giuseppe, przechowując wynik subw nowej zmiennej i sprawdzając, czy się zmieniła

-22 bajty, zwracając wektor ciągów zamiast ciągu z znakami nowej linii

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}

Wypróbuj online!

Objaśnienie dotyczące częściowo nie golfowej wersji:

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 bajtów

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

Wypróbuj online!

MATL , 21 16 bajtów

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

Używa kropek zamiast spacji dla większej przejrzystości. Dla spacji zamień 46na 32.

Wypróbuj online!

Wyjaśnienie

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)

Łuska , 23 22 bajtów

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

Dzięki Leo za -1 bajt.

Wypróbuj online!

Wyjaśnienie

Ta funkcja `G`Ipowinna być naprawdę wbudowanym ...

?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 bajtów

-10 bajtów dzięki Jonathan Frech
-3 bajtów dzięki 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;}};

Kompilacja z MSVC wymaga dezaktywacji kontroli SDL

C # (.NET Core) , 176 170 bajtów

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

Wypróbuj online!

Jest to alternatywa dla @ czyjejś odpowiedzi i po prostu wyprowadza ciągi bezpośrednio.

JavaScript (ES6), 76 bajtów

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

Wyjścia w postaci ciągu wielowierszowego.

Przypadki testowe

Używanie kropek zamiast spacji, jak robi większość odpowiedzi.

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 bajty

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

Wypróbuj online!

Oktawa , 88 83 bajtów

5 bajtów mniej dzięki 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

Wypróbuj online!

Kod maszynowy x86 dla systemu Linux, 60 bajtów

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

Jest to funkcja dla systemu Linux x86. Pobiera jako wskaźnik wejściowy do łańcucha edii długości łańcucha w ebp.

Niegolfowane, z pewną infrastrukturą do przetestowania (kompilacja z FASM, uruchamianie z ciągiem jako argumentem programu; poszukaj undress:etykiety dla rzeczywistego kodu funkcji):

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 bajtów

Na początku dodam dodatkowe miejsce, aby zabierało miejsce i wyświetlało oryginał bez dodatkowego kodu.

To całkiem nowe ... czy <? Php i spacja na początku pliku PHP dodają 6 dodatkowych bajtów, czy otrzymam to za darmo?

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

Wypróbuj online!

Pyth , 28 bajtów

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

Wypróbuj tutaj! lub Zweryfikuj wszystkie przypadki testowe!

Wyjaśnienie

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 bajtów

-1 bajt dzięki @JonathanFrech

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

Wypróbuj online!

Do zastępuje suit Test "."z " "przed wywołaniem funkcji i zastępuje " "kopię do "."przed wydrukowaniem wyniki dla jasności.

C # - jeszcze raz 125 bajtów

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

Twoje zdrowie!

Wypróbuj online!

Oktawa , 89 bajtów

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

Wypróbuj online!

Wyjaśnię to później, kiedy będę miał czas. Mogę być w stanie odegrać trochę bajtów, jeśli całkowicie zmienię podejście, ale nie widzę, jak to niestety.

Ostatnie litery określają: „sendsendendend”. Chciałbym, aby istniał sposób przechowywania endi używania tej zmiennej, ale zgadnij, co ...

Bash, 98 94 bajtów

Zapisano 4 bajty za pomocą podpowłoki zamiast sekwencji (słaba wydajność)

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

Pierwsza odpowiedź

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

Uwaga: !należy uciekać w trybie interaktywnym