Nous avons déjà maintenant comment dépouiller une chaîne de ses espaces.

Cependant, en tant que messieurs / dames, nous devrions plutôt le déshabiller .

Déshabiller une ficelle revient à la dénuder, mais en plus délicate. Au lieu de supprimer tous les espaces de début et de fin à la fois, nous les supprimons un par un . Nous alternons également entre le début et la fin, afin de ne pas brûler les étapes.

Exemple, en commençant par " codegolf "(cinq espaces de début et de fin):

     codegolf     
    codegolf     
    codegolf    
   codegolf    
   codegolf   
  codegolf   
  codegolf  
 codegolf  
 codegolf 
codegolf 
codegolf

1. Première sortie de la chaîne inchangée. Puis, affichez chaque étape. Commencez par enlever un premier espace ( le cas échéant - voir la règle n ° 2).

2. L'entrée peut avoir un nombre différent d'espaces de début et de fin. Si vous manquez d'espace d'un côté, continuez à déshabiller l'autre jusqu'à ce que la ficelle soit dénudée.

3. L'entrée peut ne pas avoir d'espaces de début ni de fin. Si c'est le cas, affichez-le tel quel.

4. Utilisez les méthodes d'E / S par défaut de PPCG . PPCG Les failles par défaut sont interdites.

5. Le comportement non défini sur une entrée vide ou contenant uniquement des espaces est correct.

6. Vous pouvez supposer que la chaîne ne contiendra que des caractères de l'espace imprimable ASCII ( 0x20to 0x7E).

Exemples - les espaces sont remplacés par des points .pour une meilleure lisibilité:

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

Un gentleman / lady est concis, donc la réponse la plus courte en octets est gagnante .

Retina , 26 octets

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

Essayez-le en ligne! (La suite de tests utilise des points pour plus de clarté. Le pied de page et l'en-tête les convertissent en espaces pour le code principal.)

Explication

Ce serait bien si nous pouvions juste alterner entre supprimer un espace de début et de fin et imprimer le résultat intermédiaire à chaque fois. Le problème est qu’à l’heure actuelle, Retina ne peut pas imprimer de manière conditionnelle et imprimerait donc ce résultat intermédiaire s’il n’y avait plus d’espace de début ou de fin, générant ainsi des doublons. (Retina 1.0 aura une option qui n'imprimera le résultat que si la chaîne a été modifiée par l'opération, mais nous n'y sommes pas encore ...)

Au lieu de cela, nous construisons une seule chaîne contenant tous les résultats intermédiaires et l’imprimons à la fin.

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

La {boucle encapsule les deux étapes du programme dans une boucle qui se répète jusqu'à ce que la chaîne cesse de changer (ce qui signifie qu'il ne reste plus aucun espace en début / fin). La scène elle-même correspond à un espace de début sur la dernière ligne de la chaîne et à cette dernière ligne, puis réécrit le match, ainsi que le contenu après l'espace sur une nouvelle ligne (supprimant ainsi l'espace de début dans la copie).

 $
 ¶$%`

Supprimer l’espace de fuite est un peu plus facile. Si nous ne faisons que correspondre à l’espace final, nous pouvons accéder aux éléments qui le précèdent (sur la même ligne) avec $%`une variante sensible à la ligne de la substitution de préfixe $`.

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

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

Essayez-le en ligne!

Python 3 , 97 95 93 90 octets

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)

Essayez-le en ligne!

Perl 6 , 55 octets

Sauvegardé de 3 octets grâce à @nwellnhof.

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

Essayez-le en ligne!

Explanation : ($_,{$++%2??S/" "$//!!S/^" "//}...*)est une séquence infinie récursive qui commence par la chaîne d'origine ( $_) et l'élément suivant est donné par le bloc appelé sur l'élément précédent.

Le bloc lui-même obtient la chaîne dans la $_variable. L'opérateur S/(regex)/(string)/recherchera la première occurrence de (regex)in $_, la remplacera par (string)et renverra le résultat. S'il n'y a pas de correspondance, il retourne le contenu de $_inchangé. Nous utilisons l'opérateur ternaire ?? !!avec la condition $++%2, qui alterne entre Falseet True( $est une variable libre qui conserve son contenu pendant les appels au bloc.)

Dans le pire des cas (tous les espaces d'un côté et 1 autre caractère), on enlève 1 espace tous les 2 pas. Nous pouvons donc être sûrs que dans les étapes 2 * (longueur de la chaîne), tous les espaces auront été supprimés. Nous prenons autant d'éléments de la séquence récursive avec [^.comb*2]et finalement joignons les doublons (qui se produisent chaque fois qu'un espace aurait dû être supprimé mais qu'il n'y est pas) avec .unique. Ceci retourne la liste des chaînes, progressivement débarrassées des espaces.

05AB1E , 21 à 15 octets

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

Essayez-le en ligne!

Explication ^

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

La version récursive est plus courte ;-)

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

Essayez-le en ligne!

C (gcc) , 107 102 101 100 99 octets

2 octets sauvés grâce à @ Jonathan Frech en utilisant des espaces et ~

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

Essayez-le en ligne!

JavaScript (ES6) 92

@Upvoters: regardez l'autre réponse de JS qui fait 76 octets de long

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

Une boucle cherchant un espace devant ou derrière. Si trouvé, supprime l'espace et la chaîne de sortie. Si aucun espace n'a été trouvé 2 fois, arrêtez.

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 octets

Sauvegardé 4 octets en raison de @Abigail .

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

Requiert -plcompté comme 2, invoqué avec -E.

Exemple d'utilisation

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

Essayez-le en ligne!

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

^{-3 octets grâce à 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;}

Essayez-le en ligne!

Java 8, 150 146 145 137 octets

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 octets grâce à @Nevay changer (f<1&s.charAt(0)<33)à f+s.charAt(0)<33.
-1 octet en utilisant le !s.trim().equals(s)truc de la réponse C # .NET de @soneone au lieu de s.matches(" .*|.* ").
-8 octets grâce à @Nevay encore une fois en changeant!s.trim().equals(s) à s!=s.trim(), car String#trimretournera " Une copie de cette chaîne avec les espaces blancs et de fin supprimés, ou cette chaîne si elle n'a pas d'espace blanc de début ou de fin ", ainsi la référence reste la même et !=peut être utilisé pour vérifier si elles sont la même référence, au lieu de .equalsvérifier la même valeur.

Explication:

Essayez-le ici (ou essayez une version plus visuelle ici au #lieu d'espaces).

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 octets

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

Essayez-le en ligne!

Gelée , 16 octets

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

Essayez-le en ligne!

-2 octets grâce à Erik the Outgolfer
-1 octet grâce aux miles

Explication

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

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

Essayez-le en ligne!

Java (OpenJDK 8) , 161 147 146 octets

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

Essayez-le en ligne!

-1 octet grâce à @ 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 octets

-8 octets en empruntant l’ idée d’Emigna qui n’a pas besoin d’être vérifiée

,v2F¬ðQi¦DNiR},}R

Essayez-le en ligne!

Je suis à peu près sûr qu'une approche moins simple peut battre cette solution facilement. Pour l'instant...

Explications:

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

-12 octets grâce à @Giuseppe, en stockant le résultat de sub dans une nouvelle variable et si elle a changé

-22 octets en renvoyant un vecteur de chaînes plutôt qu'une chaîne avec des retours à la ligne

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}

Essayez-le en ligne!

Explication sur une version partiellement non-golfée:

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 octets

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

Essayez-le en ligne!

MATL , 21 16 octets

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

Cela utilise des points au lieu d'espaces pour plus de clarté. Pour les espaces remplacer 46par 32.

Essayez-le en ligne!

Explication

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)

Husk , 23 22 octets

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

Merci à Leo pour -1 octet.

Essayez-le en ligne!

Explication

La fonction `G`Idevrait vraiment être une fonction intégrée ...

?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 octets

-10 octets grâce à Jonathan Frech
-3 octets grâce à 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;}};

La compilation avec MSVC nécessite la désactivation des contrôles SDL

C # (.NET Core) , 176 170 octets

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

Essayez-le en ligne!

Ceci est une alternative à la réponse de @ quelqu'un , et affiche simplement les chaînes directement.

JavaScript (ES6), 76 octets

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

Sort en tant que chaîne multiligne.

Cas de test

Utiliser des points plutôt que des espaces, comme le font la plupart des réponses.

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 octets

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

Essayez-le en ligne!

Octave , 88 83 octets

5 octets de moins grâce à 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

Essayez-le en ligne!

Code machine x86 pour Linux, 60 octets

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

Ceci est une fonction pour Linux x86. Il prend comme pointeur d’entrée la chaîne dans ediet la longueur de chaîne dansebp .

Ungolfed, avec une infrastructure à tester (compilation avec FASM, exécuté avec la chaîne comme argument de programme; recherchez undress:label pour le code de fonction réel):

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 octets

J'ajoute un espace supplémentaire au début pour qu'il prenne de l'espace et affiche l'original sans code supplémentaire.

Un peu nouveau pour cela ... le <? Php et l'espace au début du fichier PHP ajouteraient-ils 6 octets supplémentaires ou est-ce que je l'obtenir gratuitement?

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

Essayez-le en ligne!

Pyth , 28 octets

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

Essayez-le ici! ou Vérifiez tous les cas de test!

Explication

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 octets

-1 octet grâce à @JonathanFrech

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

Essayez-le en ligne!

La combinaison de test remplace "."par " "avant d'appeler la fonction et " "repasse sur "."avant d'imprimer les résultats pour plus de clarté.

C # - encore une fois, 125 octets

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

À votre santé!

Essayez-le en ligne!

Octave , 89 octets

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

Essayez-le en ligne!

J'ajouterai une explication plus tard, quand j'en aurai le temps. Je pourrais peut-être jouer au golf quelques octets si je change complètement d’approche, mais je ne vois pas comment, malheureusement.

Les dernières lettres ici épeler: "sendendendend". J'aimerais qu'il y ait un moyen de stocker en endtant que variable et de l'utiliser, mais devinez quoi ...

Bash, 98 94 octets

4 octets enregistrés en utilisant un sous-shell au lieu de séquences (performances médiocres)

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

Première réponse

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

Notez le !doit être échappé en mode interactif