우리는 이미 공간에서 문자열을 제거하는 방법을 이미 알고 있습니다.

그러나 적절한 신사 / 여성으로서 옷을 벗어야 합니다.

끈을 벗기는 것은 그것을 벗기는 것과 동일하며 더 섬세합니다. 모든 선행 및 후행 공백을 한 번에 제거하는 대신 하나씩 제거합니다 . 또한 계단을 태우지 않도록 선행과 후행을 번갈아 가며 나타냅니다.

예 (시작 " codegolf "과 후행 공백 5 개) :

     codegolf     
    codegolf     
    codegolf    
   codegolf    
   codegolf   
  codegolf   
  codegolf  
 codegolf  
 codegolf 
codegolf 
codegolf

1. 먼저 문자열을 변경하지 않고 출력하십시오. 그런 다음 모든 단계를 출력하십시오. 선행 공백 을 제거하여 시작 합니다 (해당되는 경우-규칙 # 2 참조).

2. 입력에 다른 수의 선행 및 후행 공백이있을 수 있습니다. 한쪽에 공간이 부족하면 끈이 벗겨 질 때까지 다른 쪽을 벗으십시오.

3. 입력에 선행 또는 후행 공백이 없을 수 있습니다. 이 경우 그대로 출력하십시오.

4. PPCG의 기본 I / O 방법을 사용하십시오 . PPCG 기본 허점 은 금지되어 있습니다.

5. 빈 입력 또는 공백 만 포함 된 입력에서 정의되지 않은 동작은 정상입니다.

6. 문자열에 ASCII 인쇄 가능 공간 ( 0x20~ 0x7E)의 문자 만 포함한다고 가정 할 수 있습니다 .

예- .가독성을 높이기 위해 공백이 점으로 대체되었습니다 .

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

신사 / 부인은 간결하므로 바이트 단위의 최단 답변이 이깁니다 .

레티 나 , 26 바이트

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

온라인으로 사용해보십시오! 테스트 스위트는 명확성을 위해 마침표를 사용합니다. 바닥 글과 머리글은주기를 주 코드의 공백으로 변환합니다.

설명

선행 및 후행 공백을 삭제하고 매번 중간 결과를 인쇄하는 것만 번갈아 가면 좋을 것입니다. 문제는 현재 Retina가 조건부로 인쇄 할 수 없기 때문에 선행 또는 후행 공백이없는 경우이 중간 결과를 인쇄하여 복제본을 생성한다는 것입니다. (Retina 1.0은 조작으로 문자열이 변경된 경우에만 결과를 인쇄하는 옵션을 얻지 만 아직 거기에 없습니다 ...)

대신 모든 중간 결과를 포함하는 단일 문자열을 작성하고 마지막에 인쇄합니다.

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

{문자열 변화 멈출 때까지 반복하는 루프 랩 프로그램의 두 단계는 (여기서 좌측에는 후행 공백 / 선도가 의미). 스테이지 자체는 문자열의 마지막 행에서 선행 공간과 해당 마지막 행을 일치시킨 다음 일치 항목과 새 행의 공백 뒤의 내용을 다시 기록합니다 (따라서 사본에서 선행 공백을 삭제함).

 $
 ¶$%`

후행 공백을 제거하는 것이 조금 더 쉽습니다. 마지막 공간과 일치 $%`하면 접두사 대체의 라인 인식 변형 인 동일한 줄의 앞에있는 항목에 액세스 할 수 있습니다 $`.

파이썬 (2) , 122 (107) 103 (102) 98 95 93 91 90 88 87 바이트

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

온라인으로 사용해보십시오!

파이썬 3 , 97 95 93 90 바이트

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)

온라인으로 사용해보십시오!

펄 6 , 55 바이트

@nwellnhof 덕분에 3 바이트를 절약했습니다.

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

온라인으로 사용해보십시오!

설명 : ($_,{$++%2??S/" "$//!!S/^" "//}...*)원래 문자열 ( $_)로 시작하는 재귀 무한 시퀀스 이며 다음 요소는 이전 요소에서 호출 된 블록에 의해 제공됩니다.

블록 자체는 $_변수 의 문자열을 가져옵니다 . 연산자 S/(regex)/(string)/는 (regex)in 의 첫 번째 항목을 검색하여로 $_바꾸고 (string)결과를 반환합니다. 일치하는 것이 없으면 $_변경되지 않은 내용을 반환합니다 . 삼항 연산자 ?? !!와 조건 $++%2사이에 삼항 연산자 를 사용합니다 . 이는 Falseand True( $블록에 대한 호출에서 내용을 보존하는 자유 변수입니다.)

최악의 경우 (한 쪽의 모든 공백과 1 개의 다른 문자), 2 단계마다 1 개의 공백을 제거합니다. 따라서 2 * (문자열 길이) 단계에서 모든 공백이 제거되었음을 확인할 수 있습니다. 우리는 재귀 순서에서 많은 요소를 가져 와서 [^.comb*2](공백을 제거해야하지만 거기에 없을 때마다 발생하는) 복제본을 버립니다 .unique. 공백이 점진적으로 제거 된 문자열 목록을 반환합니다.

05AB1E , 21 15 바이트

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

온라인으로 사용해보십시오!

설명 ^

=                 # 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 바이트

재귀 버전이 짧습니다 ;-)

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

온라인으로 사용해보십시오!

C (GCC) , 107 (102) 101 (100) 99 바이트

@Jonathan Frech 덕분에 공백을 사용하여 2 바이트를 절약하고 ~

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

온라인으로 사용해보십시오!

자바 스크립트 (ES6) 92

@Upvoters : 아래의 다른 JS 응답을 아래에서 76 바이트 길이 로 살펴보십시오.

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

앞이나 끝에 공백을 찾는 루프. 발견되면 공백과 출력 문자열을 제거하십시오. 공간이 2 번 발견되지 않으면 중지하십시오.

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>

펄 5, 32 바이트

@Abigail 로 인해 4 바이트가 저장 되었습니다 .

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

-pl로 호출 된 2로 계산 해야합니다 -E.

샘플 사용법

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

온라인으로 사용해보십시오!

C 번호 (.NET 코어) , 192 (183) 182 181 179 178 바이트

^{Kevin Cruijssen 덕분에 -3 바이트}

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

온라인으로 사용해보십시오!

자바 (8) 150 146 145 137 바이트

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 바이트 감사합니다 @Nevay 변화 (f<1&s.charAt(0)<33)에 f+s.charAt(0)<33. 대신 @someone 의 C # .NET 답변의 트릭을
사용하여 -1 바이트 . -8 바이트 덕분에 @Nevay 변경하여 다시 에 있기 때문에, "반환 선도 공백이 제거 뒤에, 또는이 문자열의 사본 이 더 선행 또는 후행 공백이없는 경우이 문자열 "따라서 기준이 동일하게 유지하고 동일한 값을 확인하는 대신 동일한 참조인지 확인하는 데 사용할 수 있습니다 .!s.trim().equals(s)s.matches(" .*|.* ")
!s.trim().equals(s)s!=s.trim()String#trim!=.equals

설명:

여기를보십시오 (또는 시각적 버전을 사용해 여기 에 #대신 공간).

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 바이트

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

온라인으로 사용해보십시오!

젤리 , 16 바이트

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

온라인으로 사용해보십시오!

Outgolfer Erik 덕분에 -2 바이트
마일 덕분에 -1 바이트

설명

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

루비 , 63 바이트

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

온라인으로 사용해보십시오!

자바 (오픈 JDK 8) , 161 (147) 146 바이트

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

온라인으로 사용해보십시오!

@Kevin Cruijssen 덕분에 -1 바이트 !

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 바이트

Emigna에서 필요없는 엔드 체크 아이디어를 빌려서 -8 바이트

,v2F¬ðQi¦DNiR},}R

온라인으로 사용해보십시오!

덜 간단한 접근법이 그 솔루션을 쉽게 이길 수 있다고 확신합니다. 지금은 ...

설명 :

,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 바이트

@Giuseppe 덕분에 -12 바이트 sub, 새로운 변수에 결과를 저장하고 변경 여부를 테스트하여

줄 바꿈이있는 문자열이 아닌 문자열 벡터를 반환하여 -22 바이트

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}

온라인으로 사용해보십시오!

부분적으로 압축 해제 된 버전에 대한 설명 :

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
}                              

자바 (오픈 JDK 8) , 137 (125) 121 120 124 바이트

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

온라인으로 사용해보십시오!

MATL , 21 16 바이트

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

더 명확하게하기 위해 공백 대신 점을 사용합니다. 스페이스 교체 46에 의해 32.

온라인으로 사용해보십시오!

설명

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)

껍질 , 23 22 바이트

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

-1 바이트의 Leo에게 감사합니다.

온라인으로 사용해보십시오!

설명

이 기능 `G`I은 실제로 내장되어 있어야합니다 ...

?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 바이트

Jonathan Frech 덕분에 -10 바이트,
Zacharý 덕분에 -3 바이트

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

MSVC로 컴파일하려면 SDL 검사를 비활성화해야합니다.

C # (. NET 코어) , 176170 바이트

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

온라인으로 사용해보십시오!

이것은 @ someone 's answer의 대안 이며 문자열을 직접 출력합니다.

자바 스크립트 (ES6), 76 바이트

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

여러 줄 문자열로 출력합니다.

테스트 사례

대부분의 답변이 수행하는 것처럼 공백 대신 점을 사용하십시오.

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 바이트

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

온라인으로 사용해보십시오!

옥타브 , 88 83 바이트

Stewie Griffin 덕분에 5 바이트 할인 !

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

온라인으로 사용해보십시오!

Linux 용 x86 기계 코드, 60 바이트

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

이것은 Linux x86 용 기능입니다. 문자열 입력 edi및 문자열 길이 입력 포인터로 사용 됩니다 ebp.

테스트 할 인프라가있는 언 골프 드 (FASM으로 컴파일하고 문자열을 프로그램 인수로 실행하십시오. undress:실제 함수 코드의 레이블을 찾으십시오 ) :

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 바이트

시작 부분에 공백을 추가하여 공백을 제거하고 추가 코드없이 원본을 표시합니다.

이것에 익숙하지 않은 ... <? php와 PHP 파일의 시작 부분에 6 바이트가 추가됩니까? 아니면 무료로 얻을 수 있습니까?

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

온라인으로 사용해보십시오!

Pyth , 28 바이트

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

여기 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오!

설명

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.

파이썬 2 , 79 바이트

@JonathanFrech 덕분에 -1 바이트

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

온라인으로 사용해보십시오!

테스트 슈트는 함수를 호출하기 전에로 대체 "."되고 명확성을 위해 결과를 인쇄 하기 전에로 " "대체 " "됩니다 ".".

C #-125 바이트

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

건배!

온라인으로 사용해보십시오!

옥타브 , 89 바이트

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

온라인으로 사용해보십시오!

시간이 있으면 나중에 설명을 추가하겠습니다. 접근 방식을 완전히 변경하면 일부 바이트에서 골프를 칠 수 있지만 불행히도 볼 수는 없습니다.

마지막 글자는 "sendsendendend"입니다. end변수 로 저장 하고 사용 하는 방법이 있었으면 좋겠지 만 무엇을 추측하십시오 ...

배쉬, 98 94 바이트

시퀀스 대신 서브 쉘을 사용하여 4 바이트 저장 (성능 저하)

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

첫 번째 답변

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

는 참고 !대화 형 모드로 이스케이프해야합니다