Ora già come rimuovere una stringa dai suoi spazi.

Tuttavia, come veri signori / signore, dovremmo piuttosto spogliarlo .

Spogliarsi di una corda equivale a toglierla, solo più delicata. Invece di rimuovere tutti gli spazi iniziali e finali contemporaneamente, li rimuoviamo uno per uno . Abbiamo inoltre si alternano tra il leader e finali, in modo da non bruciare passi.

Esempio, iniziando con " codegolf "(cinque spazi iniziali e finali):

     codegolf     
    codegolf     
    codegolf    
   codegolf    
   codegolf   
  codegolf   
  codegolf  
 codegolf  
 codegolf 
codegolf 
codegolf

1. Prima emetti la stringa invariata. Quindi, emettere ogni passaggio. Iniziare la rimozione di un leader spazio (se applicabile - vedere la Regola # 2).

2. L'input può avere un numero diverso di spazi iniziali e finali. Se esaurisci gli spazi da un lato, continua a spogliare l'altro fino a quando la stringa è spoglia.

3. L'input potrebbe non avere spazi iniziali né finali. In tal caso, emettilo così com'è.

4. Utilizzare i metodi I / O predefiniti di PPCG . Sono vietate le scappatoie predefinite PPCG .

5. Il comportamento indefinito su input vuoto o input che contiene solo spazi, è OK.

6. Si può presumere che la stringa conterrà solo caratteri dallo spazio stampabile ASCII ( 0x20a 0x7E).

Esempi: gli spazi vengono sostituiti da punti .per una migliore leggibilità:

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 gentiluomo / signora è conciso, quindi vince la risposta più breve in byte .

Retina , 26 byte

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

Provalo online! (La suite di test utilizza i punti per maggiore chiarezza. Il piè di pagina e l'intestazione li convertono in e dagli spazi per il codice principale.)

Spiegazione

Sarebbe bello se potessimo solo alternare la caduta di uno spazio iniziale e uno finale e la stampa del risultato intermedio ogni volta. Il problema è che attualmente Retina non può stampare in modo condizionale, quindi stampa anche questo risultato intermedio se non sono rimasti spazi iniziali o finali, generando duplicati. (Retina 1.0 otterrà un'opzione che stampa il risultato solo se la stringa è stata modificata dall'operazione, ma non siamo ancora arrivati ​​...)

Quindi, invece, stiamo costruendo una singola stringa contenente tutti i risultati intermedi e stampandoli alla fine.

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

La {avvolge entrambe le fasi del programma in un ciclo che si ripete finché la corda smette di variare (che significa che non non conducono / spazi finali sinistra). Lo stage stesso corrisponde a uno spazio iniziale sull'ultima riga della stringa e a quell'ultima riga, quindi riscrive la corrispondenza e le cose dopo lo spazio su una nuova riga (eliminando così lo spazio iniziale nella copia).

 $
 ¶$%`

Rimuovere lo spazio finale è un po 'più semplice. Se abbiniamo semplicemente lo spazio finale, possiamo accedere alle cose di fronte ad esso (sulla stessa linea) con $%`cui è una variante sensibile alla linea della sostituzione del prefisso $`.

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

Provalo online!

Python 3 , 97 95 93 90 byte

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)

Provalo online!

Perl 6 , 55 byte

3 byte salvati grazie a @nwellnhof.

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

Provalo online!

Spiegazione : ($_,{$++%2??S/" "$//!!S/^" "//}...*)è una sequenza infinita ricorsiva che inizia con la stringa originale ( $_) e l'elemento successivo è dato dal blocco chiamato sull'elemento precedente.

Il blocco stesso ottiene la stringa nella $_variabile. L'operatore S/(regex)/(string)/cercherà la prima occorrenza di (regex)in $_, la sostituirà con (string)e restituirà il risultato. Se non vi è alcuna corrispondenza, restituisce il contenuto di $_invariato. Usiamo l'operatore ternario ?? !!con la condizione $++%2, che si alterna tra Falsee True( $è una variabile libera che conserva il suo contenuto attraverso le chiamate al blocco.)

Nel peggiore dei casi (tutti gli spazi su un lato e 1 altro personaggio), rimuoviamo 1 spazio ogni 2 passaggi. Quindi possiamo essere sicuri che in passaggi 2 * (lunghezza della stringa), tutti gli spazi saranno stati rimossi. Prendiamo molti elementi dalla sequenza ricorsiva con [^.comb*2]e infine scartiamo i duplicati (che si verificano ogni volta che uno spazio avrebbe dovuto essere rimosso ma non è lì) con .unique. Questo restituisce l'elenco delle stringhe, progressivamente spogliate degli spazi.

05AB1E , 21 15 byte

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

Provalo online!

Spiegazione ^

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

La versione ricorsiva è più breve ;-)

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

Provalo online!

C (gcc) , 107 102 101 100 99 byte

Salvato 2 byte grazie a @Jonathan Frech usando gli spazi 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);}

Provalo online!

JavaScript (ES6) 92

@Upvoters: dai un'occhiata all'altra risposta JS in basso che è lunga 76 byte

(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 anello in cerca di uno spazio davanti o alla fine. Se trovato, rimuovere lo spazio e la stringa di output. Se non viene trovato spazio 2 volte, fermati.

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 byte

Salvato 4 byte grazie a @Abigail .

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

Richiede -plcontato come 2, invocato con -E.

Esempio di utilizzo

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

Provalo online!

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

^{-3 byte grazie 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;}

Provalo online!

Java 8, 150 146 145 137 byte

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 byte grazie a @Nevay che cambia (f<1&s.charAt(0)<33)in f+s.charAt(0)<33.
-1 byte usando il !s.trim().equals(s)trucco della risposta C # .NET di @someone invece di s.matches(" .*|.* ").
-8 byte grazie a @Nevay di nuovo cambiando !s.trim().equals(s)in s!=s.trim(), perché String#trimrestituirà " Una copia di questa stringa con spazio bianco iniziale e finale rimosso o questa stringa se non ha spazio bianco iniziale o finale ", quindi il riferimento rimane lo stesso e !=può essere utilizzato per verificare se sono lo stesso riferimento, anziché .equalsper controllare lo stesso valore.

Spiegazione:

Provalo qui (o prova una versione più visiva qui con #invece di spazi).

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 byte

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

Provalo online!

Gelatina , 16 byte

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

Provalo online!

-2 byte grazie a Erik the Outgolfer
-1 byte grazie alle miglia

Spiegazione

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

Rubino , 63 byte

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

Provalo online!

Java (OpenJDK 8) , 161 147 146 byte

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

Provalo online!

-1 byte grazie 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 byte

-8 byte prendendo in prestito l' idea di un assegno senza fine da Emigna

,v2F¬ðQi¦DNiR},}R

Provalo online!

Sono abbastanza sicuro che un approccio meno semplice possa battere facilmente quella soluzione. Per adesso...

spiegazioni:

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

-12 byte grazie a @Giuseppe, memorizzando il risultato subin una nuova variabile e verificando se è cambiato

-22 byte restituendo un vettore di stringhe anziché una stringa con newline

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}

Provalo online!

Spiegazione su una versione parzialmente non giocata:

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 byte

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

Provalo online!

MATL , 21 16 byte

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

Questo utilizza punti anziché spazi per maggiore chiarezza. Per gli spazi sostituire 46con 32.

Provalo online!

Spiegazione

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)

Buccia , 23 22 byte

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

Grazie a Leo per -1 byte.

Provalo online!

Spiegazione

La funzione `G`Idovrebbe essere davvero integrata ...

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

-10 byte grazie a Jonathan Frech
-3 byte grazie 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 compilazione con MSVC richiede la non attivazione dei controlli SDL

C # (.NET Core) , 176 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();}}}

Provalo online!

Questa è un'alternativa alla risposta di @ qualcuno e genera direttamente le stringhe.

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)

Output come una stringa multilinea.

Casi test

Usare i punti anziché gli spazi, come fanno la maggior parte delle risposte.

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 byte

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

Provalo online!

Ottava , 88 83 byte

5 byte di sconto grazie 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

Provalo online!

codice macchina x86 per 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

Questa è una funzione per Linux x86. Prende come puntatore di input la stringa in edie la lunghezza della stringa in ebp.

Ungolfed, con alcune infrastrutture da testare (compilare con FASM, eseguire con la stringa come argomento del programma; cercare l' undress:etichetta per il codice funzione effettivo):

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 byte

Aggiungo uno spazio aggiuntivo all'inizio in modo che lo spazio venga rimosso e mostri l'originale senza alcun codice aggiuntivo.

Un po 'nuovo a questo ... <p php e lo spazio all'inizio del file PHP aggiungono 6 byte extra o lo ottengo gratuitamente?

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

Provalo online!

Pyth , 28 byte

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

Provalo qui! oppure Verifica tutti i casi di test!

Spiegazione

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 byte

-1 byte grazie 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[])

Provalo online!

I sostituisce prova costume "."con " "prima di chiamare la funzione e sostituisce " "indietro a "."prima di stampare i risultati per chiarezza.

C # - ancora una volta, 125 byte

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

Saluti!

Provalo online!

Ottava , 89 byte

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

Provalo online!

Aggiungerò una spiegazione più tardi, quando avrò il tempo. Potrei essere in grado di golf di alcuni byte se cambio completamente l'approccio, ma non riesco a vedere come purtroppo.

Le ultime lettere qui spiegano: "sendendendend". Vorrei che ci fosse un modo per memorizzare endcome variabile e usarlo, ma indovina cosa ...

Bash, 98 94 byte

Salvato 4 byte usando subshell invece di sequenze (prestazioni scadenti)

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

Prima risposta

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

Nota che !deve essere evitato in modalità interattiva