Wir haben schon jetzt gelernt, wie man einen String aus seinen Räumen entfernt.

Als richtige Herren / Damen sollten wir uns jedoch lieber ausziehen .

Das Ausziehen einer Saite ist dasselbe wie das Abziehen, nur empfindlicher. Anstatt alle führenden und nachfolgenden Leerzeichen gleichzeitig zu entfernen, entfernen wir sie nacheinander . Wir wechseln auch zwischen Vor- und Nachlauf, um keine Schritte zu verbrennen.

Beispiel, beginnend mit " codegolf "(fünf führende und nachfolgende Leerzeichen):

     codegolf     
    codegolf     
    codegolf    
   codegolf    
   codegolf   
  codegolf   
  codegolf  
 codegolf  
 codegolf 
codegolf 
codegolf

1. Zuerst den String unverändert ausgeben. Geben Sie dann jeden Schritt aus. Entfernen Sie zunächst ein vorangestelltes Leerzeichen (falls zutreffend - siehe Regel 2).

2. Die Eingabe kann eine unterschiedliche Anzahl von führenden und nachfolgenden Leerzeichen enthalten. Wenn Sie auf der einen Seite keine freien Stellen mehr haben, ziehen Sie die andere Seite weiter aus, bis die Schnur leer ist.

3. Die Eingabe darf keine führenden oder nachfolgenden Leerzeichen enthalten. Wenn dies der Fall ist, geben Sie es so aus, wie es ist.

4. Verwenden Sie die Standard-E / A-Methoden von PPCG . PPCG Default Lücken sind verboten.

5. Undefiniertes Verhalten bei leerer Eingabe oder Eingabe, die nur Leerzeichen enthält, ist in Ordnung.

6. Sie können davon ausgehen, dass die Zeichenfolge nur Zeichen aus dem druckbaren ASCII-Bereich ( 0x20bis 0x7E) enthält.

Beispiele - Leerzeichen werden .zur besseren Lesbarkeit durch Punkte ersetzt :

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

Ein Gentleman / eine Dame ist prägnant, daher gewinnt die kürzeste Antwort in Bytes .

Netzhaut , 26 Bytes

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

Probieren Sie es online! (Die Testsuite verwendet aus Gründen der Übersichtlichkeit Punkte. Fußzeile und Kopfzeile konvertieren sie in und aus Leerzeichen für den Hauptcode.)

Erläuterung

Es wäre schön, wenn wir einfach abwechselnd ein vorangestelltes und ein nachgestelltes Leerzeichen löschen und jedes Mal das Zwischenergebnis ausdrucken könnten. Das Problem ist, dass Retina derzeit nicht bedingt drucken kann, sodass dieses Zwischenergebnis sogar gedruckt wird, wenn keine führenden oder nachgestellten Leerzeichen mehr vorhanden sind und Duplikate generiert werden. (Retina 1.0 erhält eine Option, die das Ergebnis nur ausgibt, wenn der String durch die Operation geändert wurde, aber wir sind noch nicht da ...)

Stattdessen bauen wir eine einzelne Zeichenfolge auf, die alle Zwischenergebnisse enthält und die am Ende gedruckt wird.

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

Die {beiden Programmphasen werden in eine Schleife eingebunden, die so lange wiederholt wird, bis sich die Zeichenfolge nicht mehr ändert (dh, es sind keine führenden / nachfolgenden Leerzeichen mehr vorhanden). Die Bühne selbst vergleicht ein führendes Leerzeichen in der letzten Zeile des Strings und in dieser letzten Zeile und schreibt dann das Match sowie das Zeug nach dem Leerzeichen in einer neuen Zeile zurück (wodurch das führende Leerzeichen in der Kopie entfernt wird).

 $
 ¶$%`

Das Entfernen des nachgestellten Leerzeichens ist etwas einfacher. Wenn wir nur das letzte Leerzeichen abgleichen, können wir auf das Zeug davor (in derselben Zeile) zugreifen, mit $%`dem eine zeilenbewusste Variante der Präfixersetzung vorliegt $`.

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

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

Probieren Sie es 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)

Probieren Sie es online!

Perl 6 , 55 Bytes

3 Bytes dank @nwellnhof eingespart.

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

Probieren Sie es online!

Erläuterung : ($_,{$++%2??S/" "$//!!S/^" "//}...*)ist eine rekursive unendliche Folge, die mit der ursprünglichen Zeichenfolge ( $_) beginnt und das nächste Element wird durch den Block angegeben, der für das vorherige Element aufgerufen wurde.

Der Block selbst erhält den String in der $_Variablen. Der Operator S/(regex)/(string)/sucht nach dem ersten Vorkommen von (regex)in $_, ersetzt es durch (string)und gibt das Ergebnis zurück. Wenn es keine Übereinstimmung gibt, wird der Inhalt $_unverändert zurückgegeben. Wir verwenden den ternären Operator ?? !!mit der Bedingung $++%2, die zwischen Falseund wechselt True( $eine freie Variable, die ihren Inhalt über Aufrufe des Blocks hinweg beibehält).

Im schlimmsten Fall (alle Leerzeichen auf einer Seite und 1 anderes Zeichen) entfernen wir alle 2 Schritte 1 Leerzeichen. Wir können also sicher sein, dass in Schritten von 2 * (Länge der Zeichenfolge) alle Leerzeichen entfernt wurden. Wir nehmen so viele Elemente aus der rekursiven Sequenz mit [^.comb*2]und verwerfen schließlich Duplikate (die immer dann auftreten, wenn ein Leerzeichen hätte entfernt werden sollen, es aber nicht vorhanden ist) mit .unique. Dies gibt die Liste der Zeichenfolgen zurück, die schrittweise von Leerzeichen befreit werden.

05AB1E , 21 15 Bytes

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

Probieren Sie es online!

Erklärung ^

=                 # 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

Rekursive Version ist kürzer ;-)

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

Probieren Sie es online!

C (gcc) : 107 102 101 100 99 Bytes

2 Bytes dank @Jonathan Frech mit Leerzeichen und ~ gespeichert

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

Probieren Sie es online!

JavaScript (ES6) 92

@Upvoters: Schauen Sie sich die andere JS-Antwort an, die 76 Byte lang ist

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

Eine Schleife, die nach einem Platz vorne oder am Ende sucht. Wenn gefunden, entfernen Sie Leerzeichen und die Ausgabezeichenfolge. Wenn 2 Mal kein Platz gefunden wurde, stoppen Sie.

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

4 Bytes aufgrund von @Abigail gespeichert .

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

Benötigt -plals 2 gezählt, mit aufgerufen -E.

Beispielnutzung

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

Probieren Sie es online!

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

^{-3 Bytes dank 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;}

Probieren Sie es 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 dank @Nevay Wechsel (f<1&s.charAt(0)<33)zu f+s.charAt(0)<33.
-1 Byte mit dem !s.trim().equals(s)Trick aus der C # .NET-Antwort von @someone anstelle von s.matches(" .*|.* ").
-8 Bytes danke an @Nevay nochmal durch Umstellung !s.trim().equals(s)auf s!=s.trim(), da String#trimwird " Eine Kopie dieser Zeichenfolge mit entferntem führenden und nachgestellten Leerzeichen oder diese Zeichenfolge, wenn sie kein führendes oder nachgestelltes Leerzeichen enthält " zurückgegeben wird !=kann verwendet werden, um zu überprüfen, ob es sich um die gleiche Referenz handelt, anstatt .equalsden gleichen Wert zu überprüfen.

Erläuterung:

Versuchen Sie es hier (oder versuchen , eine visuelle Version hier mit #anstelle von Leerzeichen).

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

Probieren Sie es online!

Gelee , 16 Bytes

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

Probieren Sie es online!

-2 Bytes dank Erik dem Outgolfer
-1 Bytes dank Meilen

Erläuterung

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

Probieren Sie es 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;}

Probieren Sie es online!

-1 Byte danke an 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 durch Ausleihen der No-Need-for-an-End-Check-Idee von Emigna

,v2F¬ðQi¦DNiR},}R

Probieren Sie es online!

Ich bin mir ziemlich sicher, dass ein weniger direkter Ansatz diese Lösung leicht schlagen kann. Zur Zeit...

Erklärungen:

,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 dank @Giuseppe, indem das Ergebnis subin einer neuen Variablen gespeichert und geprüft wird, ob es sich geändert hat

-22 Bytes durch Rückgabe eines Zeichenfolgenvektors anstelle einer Zeichenfolge mit Zeilenumbrüchen

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}

Probieren Sie es online!

Erklärung zu einer teilweise ungolften Version:

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

Probieren Sie es online!

MATL , 21 16 Bytes

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

Hierbei werden Punkte anstelle von Leerzeichen verwendet, um die Übersichtlichkeit zu erhöhen. Für Leerzeichen ersetzen Sie 46durch 32.

Probieren Sie es online!

Erläuterung

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)

Schale , 23 22 Bytes

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

Danke an Leo für -1 Byte.

Probieren Sie es online!

Erläuterung

Die Funktion `G`Isollte eigentlich eine eingebaute sein ...

?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 dank Jonathan Frech
-3 Bytes dank 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;}};

Für die Kompilierung mit MSVC müssen die SDL-Prüfungen deaktiviert werden

C # (.NET Core) , 176 bis 170 Byte

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

Probieren Sie es online!

Dies ist eine Alternative zur Antwort von @ jemandem und gibt die Zeichenfolgen direkt aus.

JavaScript (ES6), 76 Byte

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

Ausgabe als mehrzeilige Zeichenfolge.

Testfälle

Verwenden Sie Punkte anstelle von Leerzeichen, wie es die meisten Antworten tun.

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

Probieren Sie es online!

Oktave , 88 83 Bytes

5 Bytes weniger dank 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

Probieren Sie es online!

x86-Maschinencode für Linux, 60 Byte

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

Dies ist eine Funktion für Linux x86. Es nimmt als Eingabezeiger den String in ediund die Stringlänge in ebp.

Ungolfed, mit etwas zu testender Infrastruktur (mit FASM kompilieren, mit dem String als Programmargument ausführen; nach dem undress:Label für den tatsächlichen Funktionscode suchen ):

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

Ich füge zu Beginn ein zusätzliches Leerzeichen hinzu, damit das Original ohne zusätzlichen Code angezeigt wird.

Das ist ein bisschen neu ... Würden das <? Php und der Speicherplatz am Anfang der PHP-Datei 6 zusätzliche Bytes hinzufügen oder bekomme ich das kostenlos?

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

Probieren Sie es online!

Pyth , 28 Bytes

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

Probieren Sie es hier aus! oder Überprüfen Sie alle Testfälle!

Erläuterung

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 dank @JonathanFrech

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

Probieren Sie es online!

Der Testanzug ersetzt "."mit, " "bevor die Funktion aufgerufen wird, und ersetzt " "mit"." , bevor die Ergebnisse für Klarheit zu drucken.

C # - noch einmal 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);}}

Prost!

Probieren Sie es online!

Oktave , 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

Probieren Sie es online!

Ich werde später eine Erklärung hinzufügen, wenn ich Zeit habe. Ich könnte in der Lage sein, einige Bytes abzuspielen, wenn ich den Ansatz komplett ändere, aber ich kann leider nicht sehen, wie.

In den letzten Buchstaben steht "sendendendend". Ich wünschte, es gäbe eine Möglichkeit, endals Variable zu speichern und diese zu verwenden, aber raten Sie mal, was ...

Bash, 98 94 Bytes

4 Bytes mit Subshell anstelle von Sequenzen gespeichert (schlechte Leistung)

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

Erste Antwort

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

Beachten Sie, !dass im interaktiven Modus ein Escapezeichen gesetzt werden muss