รับสตริงที่ไม่ว่างเปล่าซึ่งประกอบด้วยอักขระตัวอักษรและตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ (ช่องว่าง[a-zA-Z ]) ที่ต่ำกว่าเท่านั้นให้ลดลงเป็นตัวอย่างของตัวอักษรเริ่มต้นด้วยอักขระตัวแรก

ในการลดสตริงให้เริ่มต้นด้วยอักขระตัวอักษรตัวแรกจากนั้นลบอักขระทุกตัวออกหลังจากนั้นไม่ใช่ตัวอักษรถัดไปของตัวอักษร ทำสิ่งนี้ต่อไปจนกว่าจะถึงจุดสิ้นสุดของสตริง

ตัวอย่างเช่นcodegolf:

เริ่มต้นด้วยcนำออกoเนื่องจากไม่ใช่ตัวอักษรถัดไปของตัวอักษร
เก็บdตามที่เป็นตัวอักษรตัวถัดไปและเก็บeตามที่เป็นตัวอักษรถัดไปด้วย
ลบg, oและและให้lf

ตัวอย่างสุดท้ายของคุณก็คือ 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

เกณฑ์การให้คะแนน

นี่คือโค้ดกอล์ฟซึ่งมีจำนวนน้อยที่สุดในแต่ละภาษาที่ชนะ!

JavaScript (ES6), 66 79 68 67 ไบต์

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

อย่างไร?

ทดสอบตัวอักษรต่อเนื่อง

เนื่องจากการแปลงอักขระสองตัวเป็นรหัส ASCII จะเป็นการดำเนินการที่ค่อนข้างยาวใน JS เราจึงใช้สูตรต่อไปนี้แทน:

~parseInt(b + a, 36) % 37

โดยมีเงื่อนไขว่าทั้งและ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

Python 2 , 69 ไบต์

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

ลองออนไลน์!

การลดลงของสตริงอย่างง่าย เราก็ concatenate (ord(y)-ord(x[~0]))%32==1ตัวอักษรถัดไปและถ้าหาก ตรวจสอบที่น่าเกลียดมาก - ฉันแน่ใจว่ามันสามารถปรับปรุงได้ แต่ฉันไม่แน่ใจว่า!

Python 3 , 75 85 84 91 81 77 75 ไบต์

ผมคิดว่านี่คือสั้นที่สุดเท่าที่มันจะได้รับในหลาม 3 มันสามารถจะสั้นลงโดยไม่กี่ไบต์ในหลาม 2 ดังแสดงในการส่งโกเม่

• แก้ไข: +10 สำหรับการแก้ไขข้อบกพร่อง
• แก้ไข: -1 โดยแก้ไขข้อผิดพลาดอื่น
• แก้ไข: +7 สำหรับการแก้ไขข้อผิดพลาดอื่น
• แก้ไข: -10 ไบต์ด้วยความช่วยเหลือจาก@Ruud
• แก้ไข: -4 ไบต์ตั้งแต่ OP อนุญาตให้เราแสดงตัวอักษรที่คั่นด้วยบรรทัดใหม่
• แก้ไข: -2 ไบต์ขอบคุณ@Ruudกลับไปนับไบต์เดิม!

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«

ลองออนไลน์!

-1 ขอบคุณAdnan

Brachylogขนาด 15 ไบต์

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

ลองออนไลน์!

นี่จะเป็น 10 ไบต์: ⊇.ḷ~sẠ&h~hหากไม่ใช่เพราะข้อ จำกัด "สตริงสามารถเริ่มต้นด้วยช่องว่าง" ไม่น่าสนใจพอสมควร

คำอธิบาย

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

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

ลองออนไลน์!

-27 ไบต์ขอบคุณ @Olivier Grégoire

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

บันทึก 2 ไบต์ขอบคุณ @Mr Xcoder
บันทึกแล้ว 4 ไบต์ขอบคุณ @jkelm

ลองออนไลน์!

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 ไบต์

-1 ไบต์อ้อมขอบคุณที่@Erik เคล็ดลับ Outgolfer ของ (-Qd )

-1 ไบต์ขอบคุณ @Erik the Outgolfer

VQIqZ%-CNCh-Qd32N=hZ

ลองที่นี่

Haskell, 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แต่ท้ายที่สุดแล้วก็ใช้เวลานานกว่า ...

บันทึก 8 ไบต์ต้องขอบคุณ H.PWiz!

ลองออนไลน์

Pyth, 21 20 18 ไบต์

ef&qhThQhxGrT0tyr6

ลองที่นี่

วิธีที่มีประสิทธิภาพมากกว่ารุ่น 20 ไบต์:

.U+b?t-CrZ1Creb1kZr6

ลองที่นี่

-1 ขอบคุณMr. Xcoder (ทางอ้อม)

Perl 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_/⁼-ð¡/

ลองออนไลน์!

Japté , 18 17 16 ไบต์

บันทึก 1 ไบต์ขอบคุณ @Shaggy

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 Core) , 70 60 + 18 ไบต์

-10 ไบต์ขอบคุณTheLethalCoder

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

จำนวนไบต์ยังรวมถึง:

using System.Linq;

ลองออนไลน์!

อีก 1 ไบต์(ปัจจุบัน) (ไม่ใช่อีกต่อไป) กว่า TheLethalCoder ดังนั้นการโพสต์เพื่อความสนุกสนาน วิธีการที่แตกต่างกับ LINQ

นี้ใช้ประโยชน์ของทั้งสอง C-เช่นคุณสมบัติใน C # - ตัวอักษรcharตัวแปรโดยปริยายพฤติกรรมเช่นเดียวกับจำนวนเต็มintและบูลและผู้ประกอบการไม่ดำเนินการการดำเนินการที่เหมาะสมถ้าผลตอบแทนซ้าย&& 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เคล็ดลับจากโซลูชันที่มีอยู่พร้อมกับฟังก์ชันการรวม วนซ้ำสตริงถ้าความแตกต่างระหว่างองค์ประกอบสุดท้ายของผลลัพธ์ (เช่นเริ่มต้นด้วยT"จิ้งจอกแดงด่วน ... ") และตัวละครปัจจุบันคือ 1 (หลังจากที่เป็นmod32 กับ 32) จากนั้นเราจะเพิ่มสิ่งนี้ลงใน ผลที่ได้ (ด้วยเหตุนี้เราจะทำทำไมlast 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

ลองจับคู่อักขระการค้นหาอย่างใดอย่างหนึ่ง หากพบแล้วเพิ่มการแข่งขันขึ้นสามเท่าซึ่งจะเริ่มการวนซ้ำสำหรับการค้นหาถัดไป มิฉะนั้นเพียงลบอักขระการค้นหาและส่วนที่เหลือของอินพุต

8th , 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 ไบต์

พอร์ตของการส่งงูหลาม 2

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

ลองออนไลน์!

Pyth, 15 ไบต์

eo,}r0NG_xQhNty

ชุดทดสอบ

ต่างจากคำตอบอื่น ๆ ทั้งหมดนี่ไม่ได้รวมเอาท์พุทเข้าด้วยกันมันจะสร้างองค์ประกอบทั้งหมดของอินพุตจากนั้นสั่งให้ใส่สตริงที่ต้องการในตอนท้ายและเอาท์พุทมัน

เจแก้ปัญหาบางส่วน

ฉันโพสต์สิ่งนี้เพื่อรับฟังความคิดเห็นและแนวคิดในการปรับปรุงมากกว่าสิ่งอื่นใด มันใช้งานได้ แต่ไม่ได้จัดการกับตัวพิมพ์ใหญ่และ space edge และมีความยาวสำหรับ J.

คำกริยาผู้ช่วย dyadic แรกที่บอกคุณว่า args ซ้ายและขวาอยู่ติดกันตามตัวอักษร:

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 (ทำงานได้ในคอนโซลของฉัน):