소문자와 영문자로만 구성된 빈 문자열이없는 경우 [a-zA-Z ]첫 번째 문자부터 시작하여 알파벳의 스 니펫으로 줄이십시오.

문자열을 줄이려면 첫 번째 알파벳 문자로 시작한 다음 알파벳의 다음 문자가 아닌 모든 문자를 제거하십시오. 줄 끝에 도달 할 때까지이 작업을 계속하십시오.

예를 들면 codegolf다음과 같습니다.

로 시작 c제거 o는 알파벳의 다음 문자 아니므로.
계속 d이 같은 입니다 알파벳의 다음 문자 및 유지 e는 다음 글자가 너무 때문이다.
제거 g, o및 l, 및 유지 f.

그러면 마지막 스 니펫은 cdef

규칙

• 대문자 유지되어야한다, 그래서 CodEgolF초래CdEF
• 공백은 알파벳 문자가 아니므로 문자열의 시작 부분이더라도 항상 제거해야합니다.
• 축소의 특성으로 인해 입력의 첫 번째 알파벳 문자는 항상 출력의 첫 번째 문자가됩니다.
• zZ알파벳의 마지막 글자입니다. 그 뒤에 문자가 없으며 알파벳이 반복되지 않습니다.

테스트 사례

codegolf -> cdef
CodEgolf -> CdEf
 codeolfg -> cdefg
ProgrammingPuzzles -> P
Stack Exchange -> St
The quick red fox jumped over the lazy brown dog -> Tuvw
Zebra -> Z
Abcdegfhijkl -> Abcdef

채점

이것은 code-golf 이므로 각 언어에서 가장 적은 바이트 가 이깁니다!

자바 스크립트 (ES6), 66 79 68 67 바이트

f=([c,...s],p)=>c?(p?~parseInt(c+p,36)%37:c<'!')?f(s,p):c+f(s,c):''

방법?

연속 문자 테스트

JS에서는 두 문자를 ASCII 코드로 변환하는 것이 다소 긴 작업이므로 다음 공식을 대신 사용합니다.

~parseInt(b + a, 36) % 37

모두가 제공 와 b는 에 , 위의 표현은 동일하지 않습니다 및 경우에만 경우 와 b는 연속 문자 (기본 36 즉, 연속적인 숫자)가 있으며, 어떤 문자의 경우 상관.[a-zA-Z ]0

예를 들어 :

~parseInt("Y" + "x", 36) = ~(36 * parseInt("Y", 36) + parseInt("x", 36))
                         = ~(36 * 34 + 33)
                         = -(36 * 34 + 33 + 1)
                         = -(37 * 34)

형식화 및 의견

f = ([c,                              // c = current character
         ...s],                       // s = array of remaining characters
                p) =>                 // p = previous matching letter
  c ? (                               // if there's still at least 1 character to process:
      p ?                             //   if p was already defined:
        ~parseInt(c + p, 36) % 37     //     test if p and c are NON-consecutive letters
      :                               //   else:
        c < '!'                       //     test if c is a space character
    ) ?                               //   if the above test passes:
      f(s, p)                         //     ignore c and keep the current value of p
    :                                 //   else:
      c + f(s, c)                     //     append c to the final result and update p to c
  :                                   // else:
    ''                                //   stop recursion

테스트 사례

f=([c,...s],p)=>c?(p?~parseInt(c+p,36)%37:c<'!')?f(s,p):c+f(s,c):''

console.log(f("codegolf")) // -> cdef
console.log(f("CodEgolf")) // -> CdEf
console.log(f(" codeolfg")) // -> cdefg
console.log(f("ProgrammingPuzzles")) // -> P
console.log(f("Stack Exchange")) // -> St
console.log(f("The quick red fox jumped over the lazy brown dog")) // -> Tuvw
console.log(f("Zebra")) // -> Z
console.log(f("Abcdegfhijkl")) // -> Abcdef

파이썬 2 , 69 바이트

lambda s:reduce(lambda x,y:x+y*((ord(y)-ord(x[~0]))%32==1),s.strip())

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

줄의 간단한 감소. 우리는 단지 if 만 다음 문자를 연결합니다 (ord(y)-ord(x[~0]))%32==1. 매우 못생긴 확인-개선 될 수 있다고 확신하지만 방법을 잘 모르겠습니다!

파이썬 3 , 75 85 84 91 81 77 75 바이트

나는 이것이 파이썬 3 에서 얻을 수있는 한 짧다고 생각합니다 . Sisyphus의 제출 과 같이 Python 2에서는 몇 바이트로 단축 될 수 있습니다 .

• 편집 : 버그 수정을 위해 +10
• 편집 : -1 다른 버그를 수정하여
• 편집 : 다른 버그 수정을 위해 +7
• 편집 : @ Ruud의 도움으로 -10 바이트
• 편집 : OP가 문자를 줄 바꿈으로 구분하여 출력 할 수 있기 때문에 -4 바이트
• 편집 : @Ruud 덕분에 -2 바이트 , 원래 바이트 수로 돌아갑니다!

s=input().strip();k=0
for i in s:
 if(ord(i)-ord(s[0]))%32==k:k+=1;print(i)

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

05AB1E , 13 바이트

áćsv¤yìuÇÆiy«

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

Adnan 덕분에 -1

Brachylog , 15 바이트

;ṢxS⊇.ḷ~sẠ∧Sh~h

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

이것은 ⊇.ḷ~sẠ&h~h꽤 흥미롭지 않은 "문자열은 공백으로 시작할 수 있습니다"제약 조건이 아닌 경우 10 바이트 입니다.

설명

;ṢxS               S is the Input with all spaces removed
   S⊇.             The Output is an ordered subset of the Input
     .ḷ            The Output lowercased…
        ~sẠ          …is a substring of "abcdefghijklmnopqrstuvwxyz"
           ∧
            Sh     The first char of S…
              ~h   …is the first char of the Output

이것은 상당히 선언적이므로 실제로 느립니다.

MATL , 18 16 15 바이트

실수를 지적 해 주신 Mr.Xcoder 에게 감사드립니다.

Xz1&)"t@hkd1=?@

출력의 문자는 개행으로 구분됩니다.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 (바닥 글 코드는 명확성을 위해 모든 출력 문자를 동일한 줄에 표시합니다).

설명

Xz       % Implicitly input a string. Remove spaces
1&)      % Push first character and then the remaining substring
"        % For each
  t      %   Duplicate previous character
  @      %   Push current character
  h      %   Concatenate both characters
  k      %   Convert to lowercase
  d      %   Consecutive difference. Gives a number
  1=     %   Is it 1?
  ?      %   If so
    @    %     Push current char
         %   End (implicit)
         % End (implicit)
         % Display stack (implicit)

자바 (오픈 JDK 8) , 102 (101) 74 바이트

s->{char c=0;for(char x:s)if(c<1&x>32|~-x%32==c%32)System.out.print(c=x);}

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

@Olivier Grégoire 덕분에 -27 바이트

C 번호 (모노) , 129 (107) 93 91 87 바이트

s=>{var r=s.Trim()[0]+"";foreach(var c in s)if(r[r.Length-1]%32==~-c%32)r+=c;return r;}

@Mr 덕분에 2 바이트를 절약했습니다. Xcoder.
@jkelm 덕분에 4 바이트를 절약했습니다.

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

PHP, 64 + 1 바이트

while($c=$argn[$i++])$c<A||$n&&($c&_)!=$n||(print$c)&$n=++$c&__;

파이프로 실행 -nR하거나 온라인으로 사용해보십시오 .

그렇다 보통 트릭에서 : $c도달 Z, ++$c결과 AA,
그리고 &__그 길이가 그대로 유지; 그래서 $n더 이상 일치하지 않습니다 $c.

Pyth , 23 22 21 20 바이트

@Erik the Outgolfer 's trick ( -Qd) 덕분에 간접적으로 -1 바이트 .

@Erik the Outgolfer 덕분에 -1 바이트.

VQIqZ%-CNCh-Qd32N=hZ

여기에서 시도하십시오.

하스켈, 106 (105) 97 바이트

import Data.Char
import Data.List
z=ord.toUpper
a%b|z a+1==z b=b|0<3=a
nub.scanl1(%).filter(>' ')

fromEnum수입 대신 + 문자 산술 을 사용하려고 Data.Char했지만 결국 더 길어졌습니다.

H.PWiz 덕분에 8 바이트가 절약되었습니다!

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

피스, 21 20 18 바이트

ef&qhThQhxGrT0tyr6

여기에서 시도하십시오.

보다 효율적인 20 바이트 버전 :

.U+b?t-CrZ1Creb1kZr6

여기에서 시도하십시오.

Xcoder 씨에게 (직접적으로) 감사합니다 .

펄 6 , 51 바이트

{S:i:g/\s|(\w){}<([<!before "{chr $0.ord+1}">.]+//}

그것을 테스트

넓히는:

{  # bare block lambda with implicit parameter $_

  S                          # substitute implicitly on $_, not in-place
  :ignorecase
  :global
  /

    |  \s                    # match any space

    |  (\w)                  # match a word character
       {}                    # make sure $/ is updated (which $0 uses)

       <(                    # ignore everything before this

       [

           <!before "{       # make sure this won't match after this point
             chr $0.ord + 1  # the next ASCII character
           }">

           .                 # any character

       ]+                    # match it at least once

  //                         # remove what matched
}

주 <!before …>제로 폭 주장이다

젤리 , 17 바이트

ḟ⁶;ð,ŒuṪ€O_/⁼-ð¡/

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

apt , 18 17 16 바이트

@Shaggy 덕분에 1 바이트 절약

x
c
Çc %H¥V%H©V°

온라인으로 테스트하십시오!

이것이 조금 더 짧을 것이라고 생각하고 있었지만 ... 인생은 ...

설명

x    First line: set U to the result.
x    Trim all spaces off of the input. Only necessary to remove leading spaces.

c    Second line: set V to the result.
c    Take the charcode of the first character in U.

 Ç   c %H¥ V%H© V°
UoZ{Zc %H==V%H&&V++}   Final line: output the result.
UoZ{               }   Filter to only the chars in Z where
    Zc                   the charcode of Z
       %H                mod 32
         ==V%H           equals V mod 32.
              &&V++      If true, increment V for the next letter.

C # (. NET 코어) , 70 60 + 18 바이트

TheLethalCoder 덕분에 -10 바이트

a=>{var c=a.Trim()[0];return a.Where(x=>x%32==c%32&&++c>0);}

바이트 수에는 다음이 포함됩니다.

using System.Linq;

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

TheLethalCoder의 1 바이트 이상 (현재는) (더 이상은 아닙니다) 재미를 위해 게시하십시오. LINQ를 사용한 다른 접근 방식.

이것은 C #에서 C와 같은 두 가지 기능을 이용합니다. 문자 char변수는 암시 적으로 정수와 동일하게 동작하며 int, 부울 AND 연산자 &&는 left가 a를 반환하면 올바른 연산을 실행하지 않습니다 false. 코드 설명 :

a =>                                  // Take string as input
{
    var c = a.Trim()[0];              // Delete leading spaces and take first letter
    return a.Where(                   // Filter out characters from the string, leaving those that:
               x => x % 32 == c % 32  // it's the next character in alphabet case-insensitive (thanks to modulo 32 - credits to previous answers)
               && ++c > 0             // If it is, go to the subsequent character in alphabet (and this always has to return true)
           );
}

q / kdb +, 47 45 바이트

해결책:

{10h$({(x;x,y)1=mod[y-last x;32]}/)7h$trim x}

예 :

q){"c"$({(x;x,y)1=mod[y-last x;32]}/)7h$trim x}"CodEgolf"
"CdEf"
q){"c"$({(x;x,y)1=mod[y-last x;32]}/)7h$trim x}" codeolfg"
"cdefg"
q){"c"$({(x;x,y)1=mod[y-last x;32]}/)7h$trim x}"ProgrammingPuzzles"
"P"
q){"c"$({(x;x,y)1=mod[y-last x;32]}/)7h$trim x}"The quick red fox jumped over the lazy brown dog"
"Tuvw"

설명:

컨버전스 기능 mod 32과 함께 기존 솔루션 의 트릭을 활용합니다 . 결과의 마지막 요소 (예 : "The quick red fox ..."로 시작)와 현재 문자가 1 ( 32 로 'd' 후) 사이의 차이가있는 경우 문자열을 반복 합니다. 결과 (따라서 우리가 취하는 이유를 취한 다음)를 모두 문자열로 캐스트하십시오.Tmodlast x

{10h$({(x;x,y)1=mod[y-last x;32]}/)7h$trim x} / the solution
{                                           } / lambda function
                                      trim x  / trim whitespace (leading/trailing)
                                   7h$        / cast string to ASCII (a -> 97)
     ({                         }/)           / converge
                    y-last x                  / y is the next item in the list, x contains results so far
              1=mod[        ;32]              / is the result mod 32 equal to 1
       (x;x,y)                                / if false, return x, if true return x concatenated with y
 10h$                                         / cast back to characters

Perl 5 , 30 + 1 (-n) = 31 바이트

/$b/i&&(print,$b=++$_)for/\S/g

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

방법?

/$b/i        # check if this letter equals the one in $b, ignore case
&&(print,    # output it if so
$b=++$_)     # store the next character to find
for/\S/g     # Looping over all non-whitespace characters

레티 나 , 76 바이트

 

^.
$&$&$&¶
{T`@@L@l`@l@l@`..¶
T`l`L`.¶
(.)(.)((¶).*?(\1|\2)|¶.*)
$5$5$5$4

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. 설명:

공백을 삭제하십시오.

^.
$&$&$&¶

첫 문자를 세 번 입력하고 구분 기호를 삽입하십시오.

{T`@@L@l`@l@l@`..¶
T`l`L`.¶

두 번째 및 세 번째 문자를 소문자로 변환하고 늘리십시오. 후자를 대문자로 변환하십시오. 이들은 이제 검색 문자입니다.

(.)(.)((¶).*?(\1|\2)|¶.*)
$5$5$5$4

검색 문자 중 하나를 일치 시키십시오. 발견되면 일치를 3 번 ​​반복하여 다음 검색을 위해 루프를 다시 시작합니다. 그렇지 않으면 검색 문자와 나머지 입력을 삭제하십시오.

8 일 , 114 바이트

암호

: z dup n:1+ 32 bor >r "" swap s:+ . ; 
: f s:trim 0 s:@ z ( nip dup 32 bor r@ n:= if rdrop z then ) s:each rdrop ;

설명

: z             \ n -- (r: x)
                \ print letter and save on r-stack OR-bitwised ASCII code of following letter
  dup           \ duplicate item on TOS
  n:1+          \ get ASCII code of the following letter
  32 bor        \ bitwise OR of ASCII code and 32 
  >r            \ save result on r-stack
  "" swap s:+ . \ print letter
;

: f        \ s -- 
  s:trim   \ remove trailing whitespace
  0 s:@    \ get 1st letter
  z        \ print 1st letter and save on r-stack OR-bitwised ASCII code of following letter
  ( nip    \ get rid of index
    dup    \ duplicate item on TOS
    32 bor \ bitwise OR of current ASCII code and 32 
    r@     \ get value stored on r-stack
    n:=    \ compare values to see if letter is printable or not
    if 
      rdrop \ clean r-stack
      z     \ print letter and save on r-stack OR-bitwised ASCII code of following letter
    then 
  ) 
  s:each    \ handle each character in string
  rdrop     \ clean r-stack
;

예

ok> " The quick red fox jumped over the lazy brown dog" f
Tuvw

C (gcc) , 79 78 75 70 바이트

c;f(char*s){for(c=0;*s;s++)*s^32&&!c|c==(*s|32)-1?c=32|putchar(*s):0;}

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

양성자 , 59 바이트

Python 2 제출 포트 .

s=>reduce((x,y)=>x+y*((ord(y)-ord(x[-1]))%32==1),s.strip())

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

Pyth, 15 바이트

eo,}r0NG_xQhNty

테스트 스위트

다른 모든 답변과 달리 출력을 묶지 않고 입력의 모든 하위 시퀀스를 생성 한 다음 원하는 문자열을 끝에 배치하여 출력합니다.

J, 부분 솔루션

피드백과 개선을위한 아이디어를 다른 무엇보다 게시하고 있습니다. 작동하지만 대문자 및 공백을 처리하지 않으며 J의 경우 이미 오래되었습니다.

왼쪽과 오른쪽 arg가 알파벳순으로 인접 해 있는지 알려주는 2 차원 도우미 동사 :

g=.(= <:)&(a.&i.)  NB. could save one char with u:

다음은 첫 번째 요소 에서 시작하여 알파벳 행의 일부 가 아닌 첫 번째 요소를 제거하는 동사입니다 .

f=.({~<^:3@>:@i.&0@(0,~2&(g/\))) ::]

::줄무늬가없는 요소가없는 경우 (즉, 전체 인수가 유효한 알파벳 행인 경우) Adverse 를 사용 하여 전체 인수를 변경하지 않고 반환합니다.

마지막으로 솔루션은 f수렴까지 적용하여 제공됩니다 .

f^:_ 'codegolf'  NB. => 'cdef'

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

그리고 다음은 f읽기 쉽도록 구문 분석 된 버전입니다 .

           ┌─ ~ ─── {                         
           │                              ┌─ <
           │                       ┌─ ^: ─┴─ 3
           │                 ┌─ @ ─┴─ >:      
       ┌───┤           ┌─ @ ─┴─ i.            
       │   │     ┌─ & ─┴─ 0                   
       │   │     │                            
       │   └─ @ ─┤     ┌─ 0                   
── :: ─┤         │     ├─ ~ ─── ,             
       │         └─────┤                      
       │               │     ┌─ 2             
       │               └─ & ─┴─ \ ─── / ──── g
       └─ ]         

사이드 질문 : 왜 SO에 표시 할 때 상자 문자가 완벽하게 정렬되지 않습니까?