Yalnızca küçük ve büyük harf alfabetik karakterlerden ve boşluklardan ( [a-zA-Z ]) oluşan boş olmayan bir dize verildiğinde , ilk karakterden başlayarak onu alfabenin pasajına indirgeyin.

Bir dizgeyi azaltmak için, ilk alfabetik karakterle başlayın, ardından alfabenin bir sonraki harfi olmayan her karakteri kaldırın. Dizenin sonuna ulaşana kadar bunu yapmaya devam edin.

Örneğin codegolf:

Başlayın , alfabenin bir sonraki harfi olmadığı için ckaldırın o.
Keep do kadar olduğu alfabenin sonraki harf ve tutmak eönümüzdeki mektup çok olduğu gibi.
Çıkarın g, ove l, ve saklayın f.

Son snippet'iniz o zaman olur cdef

kurallar

• Büyük harf kullanımı sürdürülmeli, CodEgolFsonuçtaCdEF
• Boşluk alfabenin bir harfi değildir ve bu nedenle dizgenin başlangıcı olsa bile daima kaldırılmalıdır.
• Azaltımın doğası gereği, girişin ilk alfabetik karakteri her zaman çıkışın ilk karakteri olacaktır .
• zZalfabenin son harfidir. Ondan sonra harf yoktur, alfabe döngü yapmaz.

Test Kılıfları

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

puanlama

Bu kod golf , her dilde en az bayt kazanıyor!

JavaScript (ES6), 66 79 68 67 bayt

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

Nasıl?

Ardışık harfleri test etme

İki karakteri ASCII kodlarına dönüştürmek JS'de oldukça uzun bir işlem olacağından, bunun yerine aşağıdaki formülü kullanıyoruz:

~parseInt(b + a, 36) % 37

Her iki şartıyla bir ve b içindedir [a-zA-Z ], yukarıda ifade eşittir 0ancak ve ancak bir ve b ardışık harfler (baz 36 yani ardışık basamak), hiçbir karakterler harf önemlidir.

Örneğin:

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

Biçimlendi ve yorumlandı

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

Test durumları

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 bayt

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

Çevrimiçi deneyin!

Dizenin basit bir azaltma. Sadece ve eğer sadece bir sonraki karakteri birleştiririz (ord(y)-ord(x[~0]))%32==1. Çok çirkin kontrol - geliştirilebileceğinden eminim, ama nasıl emin değilim!

Python 3 , 75 85 84 91 81 77 75 bayt

Bence bu Python 3'te bulabildiğin kadar kısa . Sisyphus'un gönderiminde gösterildiği gibi Python 2'deki birkaç bayt kısaltılabilir .

• EDIT: Bir hatayı düzeltmek için +10
• EDIT: -1 başka bir hatayı düzelterek
• EDIT: +7 başka bir hatayı düzeltmek için
• EDIT: @Ruud yardımıyla -10 bayt
• EDIT: -4 byte, OP bir yeni satırla ayrılmış harfleri çıkarmamıza izin verdi.
• EDIT: -2 Bayt @ Ruh sayesinde , orijinal bayt sayısına geri dönün!

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

Çevrimiçi deneyin!

05AB1E , 13 bayt

áćsv¤yìuÇÆiy«

Çevrimiçi deneyin!

-1 Adnan sayesinde

Brachylog , 15 bayt

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

Çevrimiçi deneyin!

Bu, 10 bayt olacaktır: ⊇.ḷ~sẠ&h~heğer oldukça ilginç olmayan "dizeler boşlukla başlayabilir" kısıtlaması olmasaydı.

açıklama

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

Bu oldukça bildirici olduğu için, bu da gerçekten yavaş.

MATL , 18 16 15 bayt

Mr.Xcoder'a bir hatayı işaret ettiği için teşekkürler

Xz1&)"t@hkd1=?@

Çıktıdaki harfler yeni satırlarla ayrılır.

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın (altbilgi kodu, netlik için aynı satırdaki tüm çıktı harflerini görüntüler).

açıklama

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 bayt

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

Çevrimiçi deneyin!

@Olivier Grégoire sayesinde -27 bayt

C # (Mono) , 129 107 93 91 87 bayt

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

@Mr sayesinde 2 bayt kaydedildi. Xcoder.
@Jkelm sayesinde 4 bayt kaydedildi.

Çevrimiçi deneyin!

PHP, 64 + 1 bayt

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

Pipe ile çalıştırın -nRveya çevrimiçi deneyin .

Alışılmış hileler gelen: $culaştığında Z, ++$csonuçları AA,
ve &__bu uzunluk bakir tutar; bu yüzden $nbaşka eşleşmeyecek $c.

Pyth , 23 22 21 20 bayt

-1 bayt dolaylı olarak @Erik Outgolfer'in numarası ( -Qd) sayesinde .

@ Outrikolfer @Erik sayesinde -1 bayt.

VQIqZ%-CNCh-Qd32N=hZ

Burada dene.

Haskell, 106 105 97 bayt

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

fromEnumAlmak yerine + char aritmetik kullanmaya çalıştım Data.Char, ama bu daha uzun sürdü ...

H.PWiz sayesinde 8 bayt kaydedildi!

Çevrimiçi deneyin.

Pyth, 21 20 18 bayt

ef&qhThQhxGrT0tyr6

Burada dene.

Çok daha verimli 20 baytlık versiyon:

.U+b?t-CrZ1Creb1kZr6

Burada dene.

- Bay Xcoder'a (dolaylı olarak) teşekkürler .

Perl 6 , 51 bayt

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

Dene

Expanded:

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

Bunun <!before …>sıfır genişlik iddiası olduğuna dikkat edin

Jöle , 17 bayt

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

Çevrimiçi deneyin!

Japt , 18 17 16 bayt

@Shaggy sayesinde 1 bayt kaydedildi

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

Çevrimiçi test edin!

Bunun biraz daha kısa olacağını düşünüyordum, ama ... Hayat böyle ...

açıklama

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 bayt

TheLethalCoder sayesinde -10 bayt

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

Bayt sayısı ayrıca şunları içerir:

using System.Linq;

Çevrimiçi deneyin!

TheLethalCoder'inkinden 1 bayt daha uzun (şu anda) (artık değil) bu yüzden eğlence uğruna. LINQ ile farklı yaklaşım.

Bu, C # 'daki iki C-benzeri özellikten faydalanır - karakter chardeğişkeni bir tamsayı ile aynı şekilde hareket eder intve boolean AND işleci &&sola dönerse doğru işlemi yürütmez false. Kod açıklaması:

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 bayt

Çözüm:

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

Örnekler:

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"

Açıklama:

mod 32Hile birleştirme işlevi ile birlikte mevcut çözümlerden yararlanma . Sonucun son elemanı (ör T. "Hızlı kızıl tilki ..." ile başlar) ile mevcut karakter arasındaki fark 1 ise ( mod32 ile d yedikten sonra) dizge üzerinde yineleyin . sonuç (dolayısıyla neden aldığımıza göre last x), sonra her şeyi bir dizeye geri gönderir.

{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 bayt

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

Çevrimiçi deneyin!

Nasıl?

/$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

Retina , 76 bayt

 

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

Çevrimiçi deneyin! Link, test durumlarını içerir. Açıklama:

Boşlukları sil.

^.
$&$&$&¶

İlk karakteri üç kere kopyalayın ve bir ayırıcı ekleyin.

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

İkinci ve üçüncü karakterleri küçük harfe dönüştürün ve arttırın. İkincisini büyük harfe dönüştürün. Bunlar şimdi arama karakterleri.

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

Arama karakterlerinden birini eşleştirmeyi deneyin. Bulunursa, bir sonraki aramanın döngüsünü yeniden başlatan eşleşmeyi üçe katlayın. Aksi takdirde, sadece arama karakterlerini ve girişin kalanını silin.

8 , 114 bayt

kod

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

açıklama

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

Örnek

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

C (gcc) , 79 78 75 70 bayt

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

Çevrimiçi deneyin!

Proton , 59 bayt

Python 2 gönderiminin limanı .

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

Çevrimiçi deneyin!

Pyth, 15 bayt

eo,}r0NG_xQhNty

Test odası

Diğer cevapların aksine, bu çıktıyı birbirine yapışmaz, girdilerin tüm alt dizilerini oluşturur ve daha sonra istenen dizgiyi sonuna koymalarını emreder ve çıktılar.

J, kısmi çözüm

Bunu, her şeyden daha fazla iyileştirmeye yönelik geribildirim ve fikirler için gönderiyorum. Çalışır, ancak büyük harf kullanımı ve boşluk kenarı durumlarını ele almaz ve J için zaten çok uzundur

İlk önce, sol ve sağ kenarların alfabetik olarak bitişik olup olmadığını söyleyen bir ikili yardımcı fiil:

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

Sonra, ilk öğeden başlayarak alfabetik bir çizginin parçası olmayan ilk öğeyi çıkaran bir fiil :

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

Not: ::Eğer bir çizgi olmayan öğe bulunamazsa (yani, eğer tüm değişken geçerli bir alfabetik çizgi ise), değişkenin tamamını değiştirmeden döndürmek için Ters kullanın.

Son olarak, çözüm fyakınsama kadar uygulayarak verilir :

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

Çevrimiçi deneyin!

Ve işte fkolay okuma için ayrıştırılmış bir versiyonudur :

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

Yan Soru : SO'da görüntülendiğinde kutu karakterleri neden mükemmel hizalanmıyor (konsolumda çalışıyorlar):