Ya sabemos cómo quitar una cadena de sus espacios.

Sin embargo, como caballeros / damas, debemos desvestirnos .

Desnudar una cuerda es lo mismo que pelarla, solo que más delicada. En lugar de eliminar todos los espacios iniciales y finales a la vez, los eliminamos uno por uno . También alternamos entre el inicio y el final, para no grabar pasos.

Ejemplo, comenzando con " codegolf "(cinco espacios iniciales y finales):

     codegolf     
    codegolf     
    codegolf    
   codegolf    
   codegolf   
  codegolf   
  codegolf  
 codegolf  
 codegolf 
codegolf 
codegolf

1. Primero muestra la cadena sin cambios. Luego, imprima cada paso. Comience por eliminar un espacio inicial (si corresponde, consulte la regla n. ° 2).

2. La entrada puede tener un número diferente de espacios iniciales y finales. Si te quedas sin espacios en un lado, sigue desnudando el otro hasta que la cuerda quede desnuda.

3. La entrada puede no tener espacios iniciales ni finales. Si ese es el caso, envíelo como está.

4. Utilice los métodos de E / S predeterminados de PPCG . PPCG Las lagunas predeterminadas están prohibidas.

5. El comportamiento indefinido en la entrada vacía, o la entrada que solo contiene espacios, está bien.

6. Puede suponer que la cadena solo contendrá caracteres del espacio imprimible ASCII ( 0x20a 0x7E).

Ejemplos: los espacios se reemplazan por puntos .para una mejor legibilidad:

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 caballero / dama es conciso, por lo que gana la respuesta más corta en bytes .

Retina , 26 bytes

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

Pruébalo en línea! (El conjunto de pruebas utiliza puntos para mayor claridad. El pie de página y el encabezado los convierten hacia y desde espacios para el código principal).

Explicación

Sería bueno si pudiéramos alternar entre soltar un espacio inicial y uno posterior e imprimir el resultado intermedio cada vez. El problema es que actualmente Retina no puede imprimir condicionalmente, por lo que incluso imprimiría este resultado intermedio si no quedan espacios iniciales o finales, generando duplicados. (Retina 1.0 obtendrá una opción que solo imprime el resultado si la cadena cambió la operación, pero aún no estamos allí ...)

Entonces, en cambio, estamos creando una sola cadena que contiene todos los resultados intermedios e imprimimos eso al final.

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

El {envuelve ambas etapas del programa en un bucle que se repite hasta que la cuerda deja de cambiar (lo que significa que no están conduciendo / espacios finales izquierda). El escenario en sí coincide con un espacio inicial en la línea final de la cadena, y esa línea final, y luego vuelve a escribir la coincidencia, así como las cosas después del espacio en una nueva línea (dejando caer el espacio inicial en la copia).

 $
 ¶$%`

Eliminar el espacio final es un poco más fácil. Si solo hacemos coincidir el espacio final, podemos acceder a las cosas delante de él (en la misma línea) con las $%`que hay una variante consciente de la línea de la sustitución del prefijo $`.

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

Pruébalo en línea!

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)

Pruébalo en línea!

Perl 6 , 55 bytes

Guardado 3 bytes gracias a @nwellnhof.

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

Pruébalo en línea!

Explicación : ($_,{$++%2??S/" "$//!!S/^" "//}...*)es una secuencia recursiva infinita que comienza con la cadena original ( $_) y el siguiente elemento viene dado por el bloque llamado en el elemento anterior.

El bloque mismo obtiene la cadena en la $_variable. El operador S/(regex)/(string)/buscará la primera aparición de (regex)in $_, la reemplazará por (string)y devolverá el resultado. Si no hay coincidencia, devuelve el contenido $_sin cambios. Usamos el operador ternario ?? !!con la condición $++%2, que alterna entre Falsey True( $es una variable libre que conserva su contenido a través de llamadas al bloque).

En el peor de los casos (todos los espacios en un lado y 1 otro personaje), eliminamos 1 espacio cada 2 pasos. Por lo tanto, podemos estar seguros de que en pasos de 2 * (longitud de la cadena), todos los espacios se habrán eliminado. Tomamos muchos elementos de la secuencia recursiva con [^.comb*2]y finalmente descartamos duplicados (que ocurren cada vez que un espacio debería haberse eliminado pero no está allí) con .unique. Esto devuelve la lista de cadenas, progresivamente despojado de espacios.

05AB1E , 21 15 bytes

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

Pruébalo en línea!

Explicación ^

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

La versión recursiva es más corta ;-)

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

Pruébalo en línea!

C (gcc) , 107 102 101 100 99 bytes

Ahorré 2 bytes gracias a @Jonathan Frech usando espacios y ~

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

Pruébalo en línea!

JavaScript (ES6) 92

@Upvoters: eche un vistazo a la otra respuesta JS a continuación que tiene 76 bytes de longitud

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

Un bucle que busca un espacio al frente o al final. Si lo encuentra, elimine el espacio y la cadena de salida. Si no se encuentra espacio 2 veces, deténgase.

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 debido a @Abigail .

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

Requiere -plcontado como 2, invocado con -E.

Uso de muestra

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

Pruébalo en línea!

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

^{-3 bytes gracias 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;}

Pruébalo en línea!

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 gracias a @Nevay cambiando (f<1&s.charAt(0)<33)a f+s.charAt(0)<33.
-1 byte usando el !s.trim().equals(s)truco de la respuesta C # .NET de @someone en lugar de s.matches(" .*|.* ").
-8 bytes gracias a @Nevay nuevamente al cambiar !s.trim().equals(s)a s!=s.trim(), porque String#trimdevolverá " Una copia de esta cadena con el espacio en blanco inicial y final eliminado, o esta cadena si no tiene espacio en blanco inicial o final ", por lo tanto, la referencia permanece igual y !=se puede usar para verificar si son la misma referencia, en lugar de .equalsverificar el mismo valor.

Explicación:

Pruébelo aquí (o pruebe una versión más visual aquí con en #lugar de espacios).

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

Pruébalo en línea!

Jalea , 16 bytes

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

Pruébalo en línea!

-2 bytes gracias a Erik the Outgolfer
-1 byte gracias a millas

Explicación

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

Pruébalo en línea!

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

Pruébalo en línea!

-1 byte gracias 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 tomando prestada la idea de no necesitar un cheque final de Emigna

,v2F¬ðQi¦DNiR},}R

Pruébalo en línea!

Estoy bastante seguro de que un enfoque menos directo puede superar esa solución fácilmente. Por ahora...

Explicaciones:

,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 gracias a @Giuseppe, almacenando el resultado de suben una nueva variable y comprobando si ha cambiado

-22 bytes devolviendo un vector de cadenas en lugar de una cadena con líneas nuevas

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}

Pruébalo en línea!

Explicación sobre una versión parcialmente sin golf:

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

Pruébalo en línea!

MATL , 21 16 bytes

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

Esto utiliza puntos en lugar de espacios para mayor claridad. Para espacios reemplazar 46por 32.

Pruébalo en línea!

Explicación

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)

Casco , 23 22 bytes

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

Gracias a Leo por -1 byte.

Pruébalo en línea!

Explicación

La función `G`Irealmente debería ser una función incorporada ...

?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 gracias a Jonathan Frech
-3 bytes gracias 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;}};

La compilación con MSVC requiere la desactivación de las comprobaciones 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();}}}

Pruébalo en línea!

Esta es una alternativa a la respuesta de @ alguien , y solo genera las cadenas directamente.

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)

Salidas como una cadena multilínea.

Casos de prueba

Usar puntos en lugar de espacios, como lo hacen la mayoría de las respuestas.

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

¡Pruébelo en línea!

Octava , 88 83 bytes

¡5 bytes de descuento gracias 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

Pruébalo en línea!

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 es una función para Linux x86. Toma como puntero de entrada a la cadena ediy la longitud de la cadena ebp.

Sin protección, con alguna infraestructura para probar (compilar con FASM, ejecutar con la cadena como argumento del programa; buscar la undress:etiqueta para el código de función 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

Agrego un espacio adicional al inicio para que lo saque y muestre el original sin ningún código adicional.

Un poco nuevo en esto ... ¿el <? Php y el espacio al comienzo del archivo PHP agregarían 6 bytes adicionales o lo obtengo gratis?

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

Pruébalo en línea!

Pyth , 28 bytes

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

Pruébalo aquí! o Verifique todos los casos de prueba!

Explicación

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 gracias 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[])

Pruébalo en línea!

El traje de prueba se reemplaza "."por " "antes de llamar a la función y se reemplaza " "por "."antes de imprimir los resultados para mayor claridad.

C # - una vez más, 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);}}

¡Salud!

Pruébalo en línea!

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

Pruébalo en línea!

Agregaré una explicación más tarde, cuando tenga tiempo. Podría cambiar algunos bytes si cambio el enfoque por completo, pero desafortunadamente no puedo ver cómo.

Las últimas letras aquí deletrean: "submitendendend". Desearía que hubiera una manera de almacenar endcomo variable y usar eso, pero adivina qué ...

Bash, 98 94 bytes

Guardado 4 bytes usando subshell en lugar de secuencias (bajo rendimiento)

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

Primera respuesta

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

Tenga en cuenta !que se debe escapar en modo interactivo