Натхненний Codewars Kata .

Ваша мета - взяти рядок введення, такий як цей:

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

і повернути рядок, що містить положення кожного символу в алфавіті, розділений пробілами та ігноруючи неабетичні символи, як це:

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

Для додаткового виклику ви можете замінити будь-які числові символи в початковому рядку на себе + 27. Наприклад, "25"стане "29, 32". Це абсолютно необов’язково.

Ви повинні використовувати 1-індексування ( 'a'==1, 'b'==2і т.д.)

Додаткові правила:

• Ви повинні повернути рядок, а не масив.

• Пробіл пробігу в порядку.

Переможець має найменший кількість байтів.

Удачі!

05AB1E , (5?) 7 байт

^{Правіше два байти - це вихідне форматування}

áÇ32%ðý

Порт моєї відповіді Jelly , але O5AB1E є більш лаконічним для фільтрації алфавіту.

Спробуйте в Інтернеті!

Як?

áÇ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 байт

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

-13 байт завдяки @ OlivierGrégoire .

Спробуйте в Інтернеті.

Пояснення:

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 байт

-5 байт завдяки Джо Кінгу .
-8 байт завдяки pLOPeGG .

Після цих поліпшень, ця відповідь тепер схожий на Jonathan Allan «s відповідь .

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

Спробуйте в Інтернеті!

R , 55 50 байт

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

Спробуйте в Інтернеті!

Читає введення з stdin, перетворюється на великі регістри, видаляє не великі літери алфавіту, перетворює на кодові точки, віднімає 64 моди на 32 та друкує до stdout, розділених пробілами.

Дякуємо Кевіну Крейсейну за гольф!

APL (Dyalog Unicode) , 24, 20, 14 13 байт

-4 байти дякую Захарі (та містеру Xcoder)!

-6 байт завдяки Adám!

-1 байт завдяки ngn!

⎕A⍳⎕A∩⍨≡819⌶⊢

Спробуйте в Інтернеті!

Пояснення:

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

Моє початкове рішення:

APL (Dyalog Unicode) , 24 20 байт

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

Спробуйте в Інтернеті!

Пояснення:

             ⍳           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)

Не смійся з мене, я новачок у APL :)

Python 2 , (45?) 55 байт

^{Для форматування виводу додано 11 байт, що також робить це несумісним з Python 3)}

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

Ще один порт моєї відповіді на Jelly.

Спробуйте в Інтернеті!

Неформатована версія (повернення списку цілих чисел):

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

JavaScript (Node.js) , 69 55 54 байт

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

Спробуйте в Інтернеті!

Пояснення:

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

11 байт збережено завдяки @Kevin

Ще 1 байт завдяки @Neil

Ви можете додати підтримку числових даних для деяких додаткових байтів (завдяки @neil)

JavaScript (Node.js) , 62 байти

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

Спробуйте в Інтернеті!

Желе , (7?) 8 байт

^{Крайній правий байт - це форматування виводу}

fØẠO%32K

Повна програма, що приймає рядок у форматі Python, яка виводить результат на STDOUT

Спробуйте в Інтернеті!

Як?

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 байт

r\L ¨c uH

Спробуй це

Пояснення

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

x86 опкод, 35 байт

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

Якщо припустити, що результат містить хоча б одну букву, і ні {|}~

40 байт, що дозволяє всі символи ASCII

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                           

Стакс , 9 10 9 байт

üpÉÿ%}},√

Запустіть і налагоджуйте його

-1 байт завдяки @recursive

Пояснення:

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

Стакс , 7 байт

É▌Xl»↔"

Запустіть і налагоджуйте його

Цей виводить розділений рядком новий рядок. Розпаковано:vmVaI^|c . Аналогічно, але з картою, яка неявно виводиться із заднім рядком.

Пробіл , 152 117 байт

-35 байт завдяки @Lynn .

[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]

Букви S(пробіл), T(вкладка) та N(новий рядок) додаються лише як підкреслення.
[..._some_action]додано лише як пояснення.

Спробуйте його в режимі он-лайн (лише із необробленими пробілами, вкладками та новими рядками).

Пояснення в псевдокоді:

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 байт

láÇ96-ðý

Спробуйте в Інтернеті!

або, якщо ми можемо повернути масив:

05AB1E , 6 байт

láÇ96-

Пояснення:

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

Спробуйте в Інтернеті!

або якщо ви хочете, щоб він рахував числа:

05AB1E , 13 байт

lAžh«DŠÃSk>ðý

Спробуйте в Інтернеті!

05AB1E , 14 байт

Також обробляє номери

žKÃlvžKlÙyk>ðJ

Спробуйте в Інтернеті!

Вугілля деревне , 21 байт

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

Спробуйте в Інтернеті!Посилання на багатослівну версію коду. Пояснення:

≔⁺β⭆χιβ

Додайте цифри до заздалегідь визначеної змінної малих літер.

Ｆ↧Ｓ

Переведіть петлю на нижній регістр входу.

¿№βι«

Якщо поточний символ є буквою або цифрою,

Ｉ⊕⌕βι

надрукувати свій 1-індексований індекс,

→

і залиште пробіл для наступного значення.

Червоний , 93 байти

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

Спробуйте в Інтернеті!

Perl 5 , 47 байт

З додатковим викликом розбору цифр:

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

Спробуйте в Інтернеті!

Зменшено до 38 байт шляхом ігнорування цифр

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

PHP , 70 байт

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

Спробуйте в Інтернеті!

-5 байт завдяки Кевіну

Perl 5 -p , 35 байт

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

Спробуйте в Інтернеті!

Включає додаткову частину про цифри.

Japt 2.0 -S, 9 байт

f\l ®c %H

Запустити його в Інтернеті

Пояснення:

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 байти (альфа), 41 байт (альфа + цифра)

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

Спробуйте (32 байти альфа)

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

Спробуйте (41 байт альфа + цифра)

Розширено:

32 байти альфа

{  # 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 байт альфа + цифра

{  # 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 байт

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

Спробуйте в Інтернеті!

PHP 108 105 байт

Спробуйте в Інтернеті (108 байт)

Перевірте це онлайн (105 байт)

-3 байти, завдяки @manassehkatz (Змініть рівень strtolower та видаліть AZ з регулярного виразу)

Код, намагався уникати будь-якого циклу

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

Пояснення

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

Пітон 3 , 84 байти

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

Спробуйте в Інтернеті!

Python 2, 110 байт 104 байти , з введенням користувача

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

Спробуйте в Інтернеті!

Python 2, 105 байт 104 байт 96 байт , де tпопередньо визначено:

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

Спробуйте в Інтернеті!

Давайте розбимо його з більш читаною версією:

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

Спочатку ми визначаємо alphabetяк буття, ну абетка.

Далі ми використовуємо розуміння списку для:

1. Складіть список, з якого кожен елемент є малим символом t
2. Для кожної літери, якщо її немає в алфавіті, відмовтеся від неї.
3. Якщо це так, знайдіть його індекс в алфавіті,
4. додати до нього (адже ми починаємо рахувати з 1)
5. і зробити це струною.

Нарешті ми приєднуємось до цього всі разом і друкуємо.

Редагувати: Змінено на print(і втрачено портативність), щоб зберегти байти і змусити працювати поза функцією

Редагування 2: Додана версія з input()замість попередньо визначених змінних

Редагування 3: Видалено 8 байтів у Рішеннях 1 і 2 завдяки Джо Кінгу

PowerShell , 63 байти

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

Спробуйте в Інтернеті!

(Здається довго ...)

Бере вхід $args, перетворює його .ToUpperрегістр, charпередає його як- масив, подає його в for eachцикл. Всередині циклу ми віднімаємо або себе, або 64 від значення (ASCII int), виходячи з того, чи є поточне значення -inдіапазоном 65до 90(тобто це велика літера ASCII). Ці значення залишаються на конвеєрі, і ми використовуємо -not ekval для усунення не буквених значень (тому що всі вони дорівнюють нулю). Ці числа інкапсульовані в рядок, тому що за замовчуванням класифікація масиву - це розділення його пробілом, тому ми отримуємо це досить дешево. Ця рядок залишена на конвеєрі, а вихід неявний.

MS-SQL, 133 байт

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]'

Згідно з нашими правилами вводу- виводу , введення приймається через попередньо існуючу таблицю t з полем varchar s .

Потрібен SQL 2017 або новішої версії. Необхідно також запустити в masterбазі даних, тому що я користуюсь системною таблицею під назвою spt_values, яка (коли відфільтровано поtype='P' ) містить підрахунок чисел від 0 до 2047.

В основному я приєднуюся до таблиці цифр із вхідним рядком, використовуючи SUBSTRING()який повертає окремий рядок для кожного окремого символу. Це фільтрується лише за допомогою букв LIKE'[a-z]', тоді ми отримуємо їх значення ASCII і віднімаємо 64. Ці числа з'єднуються назад у рядок за допомогою функції (нова для SQL 2017) STRING_AGG.

Pyth , 10 байт

jdfTmhxGr0

Я впевнений, що це можна трохи пограти в гольф ... -2 байт, якщо я можу вивести як список, деякі відповіді здаються, але це не в специфікації

Спробуйте в Інтернеті!

C (gcc) , 67 байт

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

Спробуйте в Інтернеті!

Перетворює кожну таблицю в малі регістри, компенсує її код на -96 і, якщо вона потрапляє в діапазон 1-індексованого алфавіту, друкує код зміщення

jq , 45 байт

[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

Спробуйте в Інтернеті