Codewars Kata'dan esinlenerek .

Amacınız böyle bir girdi dizesi almaktır:

"'Twas a dark and stormy night..."

ve alfabedeki her karakterin konumunu içeren, boşluklarla ayrılmış ve alfabetik olmayan karakterleri yoksayarak aşağıdaki gibi bir dize döndürün:

"20 23 1 19 1 4 1 18 11 1 14 4 19 20 15 18 13 25 14 9 7 8 20"

Ek bir zorluk için, orijinal dizedeki sayısal karakterleri kendileriyle + 27 değiştirebilirsiniz. Örneğin, "25"olur "29, 32". Bu tamamen isteğe bağlıdır.

Sen 1-indeksleme kullanmalıdır ( 'a'==1, 'b'==2, vs)

Ek kurallar:

• Dizi değil dizeyi döndürmelisiniz.

• Sondaki boşluk OK.

Kazanan en düşük bayt sayısına sahiptir.

İyi şanslar!

05AB1E , (5?) 7 bayt

^{En sağdaki iki bayt çıktı biçimlendirmedir}

áÇ32%ðý

Jelly cevabımın bir limanı , ama O5AB1E alfabe filtrelemesi için daha aldatıcı.

Çevrimiçi deneyin!

Nasıl?

áÇ32%ðý - take input implicitly
á       - filter keep alphabetical characters
 Ç      - to ordinals
  32    - thirty-two
    %   - modulo (vectorises)
     ð  - push a space character
      ý - join

Java 8, 82 78 72 69 62 bayt

s->{for(int c:s)System.out.print(c>64&~-c%32<26?c%32+" ":"");}

@ OlivierGrégoire sayesinde -13 bayt .

Çevrimiçi deneyin.

Açıklama:

s->                    // Method with character-array parameter and no return-type
  for(int c:s)         //  Loop over its characters as integers
    System.out.print(  //   Print:
     c>64&~-c%32<26?   //    If the current character is a letter:
      c%32+" "         //     Print the position in the alphabet with a trailing space
     :                 //    Else:
      "");}            //     Print nothing

Python 3 , 62 60 49 bayt

Jo King sayesinde -5 bayt . PLOPeGG
sayesinde -8 bayt .

Bu iyileştirmeler sonra bu cevabı şimdi benzer Jonathan Allan 'ın cevabı .

print(*[ord(c)%32for c in input()if c.isalpha()])

Çevrimiçi deneyin!

R , 55 50 bayt

cat(utf8ToInt(gsub("[^A-Za-z]","",scan(,"")))%%32)

Çevrimiçi deneyin!

Standart girdi girdi okur dönüştürür, büyük harfe kaldırır olmayan büyük harfli kod noktalarına alfabetik harfler, dönüştürür 64 çıkaran 32 ile kipler ve boşluklarla ayrılmış Stdout'a baskılar.

Kevin Cruijssen'e golf için teşekkürler!

APL (Dyalog Unicode) , 24, 20, 14 13 bayt

Zacharý (ve Bay Xcoder) sayesinde -4 bayt!

Adem sayesinde -6 bayt!

Ngn sayesinde -1 bayt!

⎕A⍳⎕A∩⍨≡819⌶⊢

Çevrimiçi deneyin!

Açıklama:

        ≡819⌶⊢  - to uppercase
   ⎕A∩⍨         - intersect with the letters A-Z (args swapped to preserve the order)
   ⍳              - index in
⎕A               - the A-Z letters list

İlk çözümüm:

APL (Dyalog Unicode) , 24 20 bayt

{⍵/⍨27>⍵}⎕A⍳1(819⌶)⊢

Çevrimiçi deneyin!

Açıklama:

             ⍳           indices of     
              1(819⌶)⊢  the right argument (⊢) changed to uppercase
          ⎕A            in the list of uppercase letters
{⍵/⍨     }              copy (filter) those items from the list of indeces
     27>⍵               which are smaller than 27 (all non A-Z chars will have index 27)

Bana gülme, APL'de yeniyim :)

Python 2 , (45?) 55 bayt

^{Çıktıyı biçimlendirmek için 11 bayt eklendi, bu da Python 3 ile uyumsuz hale getiriyor)}

lambda s:' '.join(`ord(c)%32`for c in s if c.isalpha())

Jelly cevabımın başka bir limanı.

Çevrimiçi deneyin!

Biçimlendirilmemiş sürüm (tamsayıların bir listesini döndürme):

lambda s:[ord(c)%32for c in s if c.isalpha()]

JavaScript (Node.js) , 69 55 54 bayt

t=>t.match(/[a-z]/gi).map(i=>parseInt(i,36)-9).join` `

Çevrimiçi deneyin!

Açıklama:

t =>                       // lambda function accepting a string as input
    t.match(/a-z/gi).      // returns all parts of string that match as an array 
        map(i=>            // map over that array with argument i 
            parseInt(i,36) // convert to base 36 
                - 9        // and subtract 9 from it
        ).                 // end map
        join` `            // convert to space separated string

@Kevin sayesinde 11 bayt kurtardı

@Neil sayesinde 1 bayt daha

Bazı ek baytlar için sayısal destek ekleyebilirsiniz (@neil sayesinde)

JavaScript (Node.js) , 62 bayt

t=>t.match(/[^_\W]/g).map(i=>(parseInt(i,36)+26)%36+1).join` `

Çevrimiçi deneyin!

Jöle , (7?) 8 bayt

^{En sağdaki bayt çıktı biçimlendirmedir}

fØẠO%32K

Sonucu STDOUT'a yazdıran Python biçiminde bir dizeyi kabul eden tam bir program

Çevrimiçi deneyin!

Nasıl?

fØẠO%32K - Main Link: list of characters (created from the string input)
 ØẠ      - yield the alphabet = ['A','B',...,'Z','a','b',...,'z']
f        - filter keep (discard non alphabet characters)
   O     - ordinals          ('A':65, 'Z':90, 'a':97, 'z':122, etc.)
     32  - literal thirty-two
    %    - modulo            (65:1,   90':26,  97:1,  122:26,  etc.)
       K - join with spaces (makes a list of characters and integers)
         - implicit print

Japt v2.0a0 -S, 12 10 bayt

r\L ¨c uH

Dene

açıklama

r              :Remove
 \L            :  Non-letter characters
    ¬          :Split to array
     ®         :Map
      c        :  Character code
        u      :  Modulo
         H     :  32
               :Implicitly join with spaces and output

x86 opcode, 35 bayt

0080h: AC 3C 24 75 04 88 45 FF C3 0C 20 2C 60 76 F1 D4
0090h: 0A 0D 30 30 86 E0 3C 30 74 01 AA 86 E0 AA B0 20
00a0h: AA EB DD                                       

f:  lodsb
    cmp al, '$'
    jnz @f
        mov [di-1], al
        ret
    @@:
    or al, 32
    sub al, 96
    jbe f
    aam
    or ax, 3030H
    xchg ah, al
    cmp al, 48
    jz @f
        stosb
    @@:
    xchg ah, al
    stosb
    mov al, 32
    stosb
    jmp f

Sonucun en az bir harf içerdiği varsayılarak, hayır {|}~

40 bayt, tüm ASCII karakterlerine izin verir

0080h: AC 3C 24 75 04 88 45 FF C3 0C 20 2C 60 76 F1 3C
0090h: 1A 77 ED D4 0A 0D 30 30 86 E0 3C 30 74 01 AA 86
00a0h: E0 AA B0 20 AA EB D9                           

Stax , 9 10 9 bayt

üpÉÿ%}},√

Çalıştır ve hata ayıkla

@Recursive sayesinde -1 bayt

Açıklama:

v{VaIvm0-J Full program, unpacked, implicit input
v          Lowercase
 {    m    Map:
  VaI        Index in lowercase alphabet (0-based, -1 for not found)
     ^       Increment
       0-  Remove zeroes
         J Join by space
           Implicit output

Stax , 7 bayt

É▌Xl»↔"

Çalıştır ve hata ayıkla

Bu satırsonu ayrılmış çıktılar verir. Ambalajsız: vmVaI^|c. Benzer, ancak son satırsonu ile örtük olarak çıktı veren harita ile.

Boşluk , 152 117 bayt

@Lynn sayesinde -35 bayt .

[N
S S N
_Create_Label_LOOP][S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve][S N
S _Duplicate_input][S S S T S S S S S N
_Push_32][T S T T   _Modulo][S N
T   _Swap_top_two][S S S T  T   T   T   T   T   N
_Push_63][T S T S _Integer_divide][T    S S N
_Multiply][S N
S _Duplicate][S S S T   T   S T T   N
_Push_27][S T   S S T   N
_Copy_1st][S S S T  N
_Push_1][T  S S S _Add][T   S T S _Integer_divide][T    S S N
_Mulitply][N
T   S N
_If_0_Jump_to_Label_LOOP][T N
S T _Print_as_number][S S S T   S S S S S N
_Push_32_space][T   N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

Harfler S(boşluk), T(sekme) ve N(yeni satır) yalnızca vurgulama olarak eklendi.
[..._some_action]yalnızca açıklama olarak eklendi.

Çevrimiçi deneyin (yalnızca ham alanlar, sekmeler ve yeni satırlarla).

Sahte kodda açıklama:

Start LOOP:
  Character c = STDIN as character
  Integer n = (c modulo-32) * (c integer-divided by 63)
  Integer m = 27 integer-divided by (n + 1) * n;
  If(m == 0):
    Go to next iteration of LOOP
  Else:
    Print n as integer to STDOUT
    Print a space to STDOUT
    Go to next iteration of LOOP

05AB1E , 8 bayt

láÇ96-ðý

Çevrimiçi deneyin!

veya bir dizi döndürebilirsek:

05AB1E , 6 bayt

láÇ96-

Açıklama:

l         Lowercase
 á        Only letters
  Ç       Codepoints
   96-    Subtract 96.

Çevrimiçi deneyin!

veya sayıları saymasını istiyorsanız:

05AB1E , 13 bayt

lAžh«DŠÃSk>ðý

Çevrimiçi deneyin!

05AB1E , 14 bayt

Sayıları da işler

žKÃlvžKlÙyk>ðJ

Çevrimiçi deneyin!

Kömür , 21 bayt

≔⁺β⭆χιβＦ↧Ｓ¿№βι«Ｉ⊕⌕βι→

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

≔⁺β⭆χιβ

Rakamları önceden tanımlanmış küçük harfler değişkenine ekleyin.

Ｆ↧Ｓ

Küçük harfli girişin üzerinde döngü yapın.

¿№βι«

Geçerli karakter bir harf veya rakamsa,

Ｉ⊕⌕βι

1 dizinli dizinini yazdırır,

→

ve bir sonraki değer için boşluk bırakın.

Kırmızı , 93 bayt

func[s][a: charset[#"a"-#"z"]parse lowercase s[any[copy c a(prin[-96 + to-char c""])| skip]]]

Çevrimiçi deneyin!

Perl 5 , 47 bayt

Rakamları ayrıştırmada ek zorluklarla:

print map{(ord(uc)-64)%43," "}<>=~/([A-Z\d])/gi

Çevrimiçi deneyin!

Rakamları yok sayarak 38 bayta düşürüldü

print map{ord()%32," "}<>=~/([A-Z])/gi

PHP , 70 bayt

for(;$c=$argv[1][$i++];)if(($c=ord($c))>64&($c%=32)>0&$c<27)echo"$c ";

Çevrimiçi deneyin!

Kevin sayesinde -5 bayt

Perl 5 -p , 35 bayt

$_="@{[map{(-64+ord uc)%43}/\w/g]}"

Çevrimiçi deneyin!

Rakamlarla ilgili ekstra kısmı içerir.

Japt 2,0 -S, 9 bayt

f\l ®c %H

Çevrimiçi çalıştırın

Açıklama:

f\l ®c %H                                    Input: "Hello..."
f            Match:
 \l             [A-Za-z]                     ["H","e","l","l","o"]
    ®        Map Z over the results:
     c         char-code of Z                [72,101,108,108,111]
       %H      mod 32                        [8,5,12,12,15]
-S           Join the chars with a space     8 5 12 12 15

Perl 6 , 32 bayt (alfa), 41 bayt (alfa + basamak)

{~(.uc.comb(/<:L>/)».ord X-64)}

Deneyin (32 bayt alfa)

{~((.uc.comb(/<:L+:N>/)».ord X-64)X%43)}

Deneyin (41 bayt alfa + basamak)

Expanded:

32 bayt alfa

{  # bare block lambda with implicit parameter $_

  ~( # coerce to string (space separated)

      .uc                      # uppercase
      .comb( / <:L > / )\      # get letters as a sequence
      ».ord                    # get the ordinal of each
      X- 64                    # subtract 64 from each
  )
}

41 bayt alfa + basamak

{  # bare block lambda with implicit parameter $_

  ~( # coerce to string (space separated)
    (
      .uc                      # uppercase
      .comb( / <:L + :N > / )\ # get letters and numbers as a sequence
      ».ord                    # get the ordinal of each
      X- 64                    # subtract 64 from each
    ) X% 43                    # modulus 43 for each
  )
}

Tcl , 93 bayt

puts [lmap c [split $argv ""] {if [string is alp $c] {expr ([scan $c %c]-64)%32} {continue}}]

Çevrimiçi deneyin!

PHP 108 105 Bayt

Çevrimiçi deneyin (108 Bytes)

Çevrimiçi olarak tri başlat (105 Bayt)

-3 Bytes, @manassehkatz sayesinde (Strtolower seviyesini değiştirin ve AZ'yi normal ifadeden kaldırın)

Kod, herhangi bir döngüden kaçınmaya çalıştı

<?=strtr(implode(" ",str_split(preg_replace(
"/[^a-z]/",'',strtolower($argv)))),array_flip(range("`",z)));

açıklama

$string = preg_replace("/[^a-z]/",'',strtolower($argv))  
//the string only contains letters

$string = implode(" ",str_split($string)); 
//the string has a space after every letter

$string = strtr($string, array_flip(range("`",z)));  
//replace every letter   acording to the array

$replacementArray = array_flip(range("`",z));
//this array contains the ansi characters from "`" to the "z"
//array_flip to change the keys with the values
//final array ["`"=>0,"a"=>1, "b"=>2...."z"=>26]

Python 3 , 84 bayt

print(*filter(int,['abcdefghijklmnopqrstuvwxyz'.find(c)+1for c in input().lower()]))

Çevrimiçi deneyin!

Python 2, 110 bayt 104 bayt , kullanıcı girişi ile

a="abcdefghijklmnopqrstuvwxyz";print" ".join(str(a.index(l)+1)for l in list(input().lower())if l in a)

Çevrimiçi deneyin!

Python 2, 105 bayt 104 bayt 96 bayt , burada tönceden tanımlanmıştır:

a="abcdefghijklmnopqrstuvwxyz";print" ".join(str(a.index(l)+1)for l in list(t.lower())if l in a)

Çevrimiçi deneyin!

Daha okunabilir bir sürümle parçalayalım:

alphabet = "abcdefghijklmnopqrstuvwxyz"
foo = [str(alphabet.index(letter) + 1) for letter in list(t.lower()) if letter in alphabet]
print " ".join(foo)

İlk olarak, alphabet olarak, alfabe olarak .

Ardından, liste kavrayışını şu amaçlarla kullanırız:

1. Her öğenin küçük harfli olduğu bir liste yapın t
2. Her harf için, alfabede değilse, atın.
3. Eğer öyleyse, dizinini alfabede bulun,
4. bir tane ekleyin (çünkü 1'de saymaya başlarız)
5. ve bir dize yap.

Sonunda, hepsini bir araya getirip yazdırıyoruz.

Düzenleme: Baytları printkaydetmek ve bir işlevin dışında çalışmasını sağlamak için değiştirildi (ve kayıp taşınabilirlik)

Düzenleme 2:input() Önceden tanımlanmış değişkenler yerine bir sürüm eklendi

Düzenleme 3: Jo King sayesinde Çözüm 1 ve 2'de 8 bayt kaldırıldı

PowerShell , 63 bayt

"$(([char[]]"$args".ToUpper()|%{$_-($_,64)[$_-in65..90]})-ne0)"

Çevrimiçi deneyin!

(Uzun görünüyor ...)

Girdi alır $args , büyük / .ToUpperküçük harf dönüştürür , char-dizeli olarak verir, bunu bir for eachdöngüye besler . Döngünün içinde, geçerli değerin -inaralığa ( aralık 65) 90(yani, bir ASCII büyük harfidir) bağlı olarak, kendisini veya 64'ü (ASCII int) değerinden çıkarırız . Bu değerler boru hattında bırakılır ve bir-ne düzende bırakılır ve harf olmayan değerleri ortadan kaldırmak için ot qual kullanırız (çünkü hepsi sıfırdır). Bir dizinin varsayılan dizilimi onu boşluktan ayırmak olduğundan, bu sayılar bir dizede kapsüllenir, bu yüzden bunu oldukça ucuza alırız. Bu dize ardışık düzende bırakılır ve çıktı örtüktür.

MS-SQL, 133 bayt

SELECT STRING_AGG(ASCII(substring(upper(s),number+1,1))-64,' ')FROM
spt_values,t WHERE type='P'AND substring(s,number+1,1)LIKE'[a-z]'

Bizim IO kuralları Başına , giriş önceden varolan tablo aracılığıyla alınır t varchar alan ile s .

SQL 2017 veya üstü gerekir. masterVeritabanında da çalıştırılmalıdır , çünkü spt_values(filtrelendiğinde type='P') 0'dan 2047'ye kadar sayma sayıları içeren bir sistem tablosundan yararlanıyorum .

Temelde SUBSTRING()her bir karakter için ayrı bir satır döndüren kullanarak , girdi dizesi ile bir sayı tablosuna katılıyorum . Bu, yalnızca harfler kullanılarak filtrelenir LIKE'[a-z]', sonra ASCII değerlerini alır ve 64 çıkarırız. Bu sayılar (SQL 2017'de yeni) işlevi kullanılarak bir dizeye geri eklenir STRING_AGG.

Pyth , 10 bayt

jdfTmhxGr0

Eminim bu biraz golf olabilir ... -2 bayt bir liste olarak çıktı, bazı cevaplar gibi görünüyor ama spec değil

Çevrimiçi deneyin!

C (gcc) , 67 bayt

c;f(char*s){for(;*s;)(c=tolower(*s++)-96)>0&c<27&&printf("%d ",c);}

Çevrimiçi deneyin!

Her karakteri küçük harfe dönüştürür, kodunu -96 ile öteler ve 1 dizinli alfabe aralığına girerse ofset kodunu yazdırır

jq , 45 bayt

[gsub("\\W";"")|explode[]%32|@text]|join(" ")

 gsub("\\W";"")                                # remove non-alpha characters
               |explode[]                      # get decimal values of characters
                         %32                   # get positions in alphabet
                            |@text             # convert back to string
[                                 ]|join(" ")  # join with a space

Çevrimiçi deneyin