Поиск по алфавиту

10

Вдохновленный 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и т.д.)

Дополнительные правила:

  • Вы должны вернуть строку, а не массив.

  • Конечный пробел в порядке.

Победитель имеет наименьшее количество байтов.

Удачи!

code-golf string number Тео С
источник
тесно связаны
Джузеппе
5
@TheoC Почему? Общее мнение заключается в том, что ответы должны быть в состоянии выводить в любом разумном формате, поскольку это может добавить слишком много раздувания и сделать его несправедливым по отношению к языкам, которые могут объединять пробелы более коротким способом.
Okx
1
@TheoC Почему бы тебе просто не позволить и то и другое?
Okx
3
Добро пожаловать в PPCG! В целом, это достойный вызов, но в следующий раз, когда вы опубликуете его, вот несколько вещей, о которых следует помнить. 1) Эта задача довольно проста. Я думаю, что было бы более интересно, если бы необязательная часть была обязательной (обратите внимание, не меняйте эту часть сейчас, слишком поздно). 2) Вы довольно ограничительны в отношении некоторых произвольных частей. Почему бы не разрешить массив? Это наши стандарты , чем массив символов является строкой . Я бы порекомендовал прочитать эту ветку для идей.
Джеймс
2
Примечания к будущему: индексирование 1 и 0 обычно одно и то же, и оба обычно разрешены. Кроме того, ограничивающие выходные форматы осуждаются. Если это список значений, пусть язык определяет формат. Проблема не в форматировании вывода и не в смещении индексов. Следовательно, это не должно быть ограничением, когда вы можете просто позволить языкам делать то, что они делают естественным образом, и сосредоточиться на цели вызова.
Волшебная Урна Осьминога

Ответы:

5

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
Джонатан Аллан
источник
Так как OP хочет, чтобы он печатался разделенным пробелами, ðýможно добавить трейлинг . Но так как половина списков вывода ответов, я думаю, просто оставьте это пока.
Кевин Круйссен
Ах. Я пропустил это в своих ответах ...
Джонатан Аллан
5

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
Кевин Круйссен
источник
1
s->s.chars().forEach(c->{if(c>64&~-c%32<26)System.out.print(c%32+" ");})(72bytes).
Оливье Грегуар
1
@ OlivierGrégoire Спасибо! И еще на 3 байта, изменив его на троичный, если. :)
Кевин Круйссен
s->{for(int c:s)System.out.print(c>64&~-c%32<26?c%32+" ":"");}(62 байта), используя в char[]качестве входных данных вместо String.
Оливье Грегуар
4

R , 55 50 байт

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

Попробуйте онлайн!

Считывает ввод из стандартного ввода, преобразует в верхний регистр, удаляет не прописные буквенные буквы, преобразует в кодовые точки, вычитает до 64 мод на 32 и печатает в стандартный вывод, разделенный пробелами.

Спасибо Кевину Круйссену за гольф!

Giuseppe
источник
50 байтов
Кевин Круйссен
@KevinCruijssen * facepalm * Дух
Джузеппе
Я добавил два комментария (вопроса) к вопросу - в зависимости от ответа есть возможность увеличить это до 46 или даже 39 символов.
JayCe
1
Вы можете сделать 47 с помощью[^A-z]
MickyT
4

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

-4 байта благодаря Захари (и мистеру Xcoder)!

-6 байт благодаря Адаму!

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

Гален Иванов
источник
1
Это на самом деле замечательно хорошо для кого-то нового в APL! Вам не нужны скобки, они предполагаются. Также {1(819⌶)⍵}может быть 1(819⌶)⊢. Иначе потрясающая работа! Надеюсь, вам понравится APL в будущем!
Захари
@ Zacharý Спасибо! Я надеюсь на это (у меня есть некоторые знания в области J, я не совсем новичок в языках массивов)
Гален Иванов
1
Как отметил Захари, скобки предполагаются , поэтому вам не нужно включать их в число байтов, в результате чего получается 20 байтов.
Мистер Кскодер,
1
@Jonah Я добавил объяснение. Вы правы, заглавные буквы и сам алфавит стоят в J. гораздо дороже
Гален Иванов
1
Хорошая работа! Вы можете сохранить байты путем компоновки 1к 819⌶и сохранить пять пути удаления 27s непосредственно: 27~⍨⎕A⍳819⌶⍨∘1; или пересечение с алфавитом:⎕A⍳⎕A∩⍨819⌶⍨∘1
Адам
3

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

11 байтов добавлено для форматирования вывода, что также делает это несовместимым с Python 3)

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

Еще один порт моего желе ответа.

Попробуйте онлайн!

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

lambda s:[ord(c)%32for c in s if c.isalpha()]
Джонатан Аллан
источник
1
Похоже, что OP настаивает на выводе строк, разделенных пробелами, к сожалению
Сок
1
Да - я пропустил это на всех моих ответах - каждый становится настолько привыкшим к нормам сайта!
Джонатан Аллан
3

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` `

Попробуйте онлайн!

Мухаммед Салман
источник
-11 байтов, переходя a-zна A-Za-zи i.toLowerCase().charCodeAt()-96кi.charCodeAt()%32
Кевин Круйссен
1
parseInt(i,36)-9сохраняет еще один байт.
Нил
.match(/[^_\W]/g).map(i=>(parseInt(i,36)+26)%36+1)позволяет поддерживать номера, но не уверен, что это лучший способ.
Нил
2

Желе , (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
Джонатан Аллан
источник
2

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
мохнатый
источник
2

код операции 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
l4m2
источник
Что такое "код операции x86"? Это просто отправка машинного кода на x86?
Якоб
@ Якоб правда. Я здесь не говорю ".COM", потому что это функция и не полагаюсь на формат ".COM"
l4m2
Хм. Да, я думаю, предполагается, что решения машинного кода не должны быть полными исполняемыми файлами. На самом деле может быть лучше просто пометить его как «машинный код x86»
Jakob
2

Stax , 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

Stax , 7 байт

É▌Xl»↔"

Запустите и отладьте его

Этот выводит новую строку-разделенную. Распакованный: vmVaI^|c. Аналогично, но с картой, которая неявно выводится с завершающим переводом строки.

Wastl
источник
Гектометр Кажется, есть проблемы с упаковкой программ, которые заканчиваются в космосе
рекурсивно
@recursive Да, не заметил этого (обычно я пробую ссылки, но, видимо, я забыл это здесь). Я добавил обходной путь.
Wastl
Я никогда не замечал эту ошибку. Я исправлю это в следующем выпуске Stax. Существующие упакованные программы останутся без изменений.
рекурсивный
Вот 9 назад для вашей проблемы.
рекурсивный
2

Пробел , 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
Кевин Круйссен
источник
1
У меня нет времени, чтобы написать это в Whitespace, но, возможно, вы могли бы написать что-то вроде этого
Линн
1
Похоже, это 117 байтов ! (* Я изменил 64 на 63 в коде, так как это эквивалентно, но короче, чтобы представлять в пробелах) :)
Линн
@ Линн Неплохо, тут -35 байт. Спасибо. :)
Кевин Круйссен
1

Древесный уголь , 21 байт

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

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение:

≔⁺β⭆χιβ

Добавьте цифры к предопределенной переменной строчных букв.

Ｆ↧Ｓ

Цикл на входе в нижнем регистре.

¿№βι«

Если текущий символ является буквой или цифрой,

Ｉ⊕⌕βι

напечатать его 1-индексированный индекс,

→

и оставьте место для следующего значения.

Нил
источник
1

Красный , 93 байта

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

Попробуйте онлайн!

Гален Иванов
источник
Я недостаточно знаю о красном, но его #"a"-#"z"можно изменить как на строчные, так и на прописные буквы; а затем lowercaseможет быть удален; а -96 + to-char cможно по модулю-32? Не уверен, что это даже спасет байты в красном, хотя.
Кевин Круйссен
@Kevin Cruijssen Спасибо, попробую позже
Гален Иванов
parseФункция @KevinCruijssen собирает строки, даже если совпадение является одним символом, поэтому мне всегда нужно to-char. Для заглавных букв мне нужно добавить в кодировку # "A" - # "Z", что портит усиление (если оно есть) от устранения lowercase.
Гален Иванов
Да, я #"A"-#"Z"немного боялся, возможно, не сильно выиграет lowercase, потому что это всего на 1 байт короче. И я знал, что вам понадобится to-char, просто не был уверен, что -96 + и по модулю 32 будут одинакового размера.
Кевин Круйссен
1

Perl 5 , 47 байт

С дополнительным вызовом разбора цифр: 

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

Попробуйте онлайн!

Уменьшено до 38 байт за счет игнорирования цифр

print map{ord()%32," "}<>=~/([A-Z])/gi
fockjef
источник
1

PHP , 70 байт

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

Попробуйте онлайн!

-5 байт благодаря Кевину

user2803033
источник
Фрагменты здесь не допускаются в качестве представлений, но вы можете сделать это функцией или полной программой.
Нисса
Извините, теперь он использует первый аргумент в качестве входных данных
user2803033
Привет, добро пожаловать в PPCG! Если вы еще этого не сделали, вам может быть интересно прочитать советы по игре в гольф на PHP и советы по игре в гольф на всех языках . Что касается запчастей, то вы можете &&играть в гольф: можно &и ord(strtolower($c))-96можно ord($c)%32. Кроме того, я думаю, что вы можете удалить ~ранее $c, но я не уверен. Я не слишком много программировал на PHP и не знаю, для чего ~он используется здесь.
Кевин Круйссен
Спасибо за ваш вклад. Мод 32 хорошая идея. Он сохраняет некоторые байты, но требует дополнительной проверки, чтобы убедиться, что ord ($ c) больше 64.
user2803033
1

Perl 5 -p , 35 байт

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

Попробуйте онлайн!

Включает дополнительную часть о цифрах.

Xcali
источник
1
/\w/включает в себя_
Брэд Гилберт b2gills
Гораздо меньше, чем я играл! Вы можете сохранить один байт и исправить упомянутую ошибку @ BradGilbertb2gills, используя -F/[^0-9\pL]|/: Попробуйте онлайн!
Дом Гастингс
1

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
Оливер
источник
1

Perl 6 , 32 байта (альфа), 41 байт (альфа + цифра)

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

Попробуй (32 байта альфа)

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

Попробуйте это (41 байт букв + цифра)

Expanded:

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
  )
}
Брэд Гилберт b2gills
источник
Это также соответствует не-ASCII-символам, как Э, но я попросил у OP пояснить, является ли ввод только ASCII или нет.
Джо Кинг,
1

PHP 108 105 байт

Попробуйте онлайн (108 байт)

Tri это онлайн (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]
Франциско Хан
источник
Чтобы заставить его работать без предупреждений, мне пришлось (а) изменить $ argv на $ argv [1] и (б) добавить «вокруг последнего z. Но с этими изменениями или без них (которые могут зависеть от версии - я Я использую 5.6), вы можете сэкономить 3 байта, перемещая strtolower () на уровень strtolower($argv)и удаляя заглавные буквы A-Zиз регулярного выражения.
manassehkatz-Moving 2 Codidact
На php 7 выдается предупреждение, я собираюсь изменить ответ прямо сейчас. Извините, просто нет, у меня было время проверить :-D
Франциско Хан
1
@manassehkatz Принял ваше предложение и сэкономил 3 байта, большое спасибо.
Франциско Хан
Разве это не должно быть $argv[1]или $argnвместо $argv? joinна 3 байта короче implode.
Тит
0

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 благодаря Джо Кинг

Тео С
источник
В вашем коде 6 посторонних пробелов
Джо Кинг,
@JoKing Я нашел три (после точки с запятой, окружающие +), где остальные?
Тео С
Перед тем if, forи" "
Джо Кинг
Вы также можете удалить []вjoin
Джо Кинг
Еще раз добро пожаловать в PPCG! К сведению, по умолчанию (т. Е. Если явно не переопределено в вопросе) ответы могут быть функциями или полными программами (например, ваша 104-байтовая версия), но не фрагментами (как ваша 96-байтовая версия). Здесь вы можете отправить версию, которая создает функцию, которая возвращает строку для 100 байтов :)
Джонатан Аллан
0

PowerShell , 63 байта

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

Попробуйте онлайн!

(Кажется долго ...)

Принимает входные данные $args, преобразует их в .ToUpperрегистр , преобразует их как char-array, передает их в for eachцикл. Внутри цикла мы вычитаем либо сам или 64 из значения (ASCII INT), в зависимости от того или нет текущее значение -inдиапазона 65для 90(то есть, что это заглавная буква ASCII). Эти значения остаются в конвейере, и мы используем -not equal для удаления не буквенных значений (потому что все они равны нулю). Эти числа инкапсулированы в строку, так как стандартная строковая спецификация массива состоит в том, чтобы разделить его пробелами, поэтому мы получаем это довольно дешево. Эта строка остается в конвейере и вывод неявный.

AdmBorkBork
источник
0

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.

BradC
источник
0

Pyth , 10 байт

jdfTmhxGr0

Я почти уверен, что это может быть чуть-чуть ... -2 байта, если я могу вывести в виде списка, некоторые ответы, кажется, но это не в спецификации

Попробуйте онлайн!

Дейв
источник
Вы можете удалить последние d( jdfTmhGr010 байт).
г-н Xcoder
0

C (gcc) , 67 байт

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

Попробуйте онлайн!

Преобразует каждый символ в нижний регистр, смещает его код на -96 и, если он попадает в диапазон алфавита с 1 индексом, печатает код смещения

vazt
источник
0

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

Попробуйте онлайн

Наим Фавье
источник