Введение

Какую часть английского алфавита использует данная строка? Предыдущее предложение использует 77%. В нем 20 уникальных букв (howmucftenglisapbdvr) и 20/26 ≃ 0,77.

Вызов

Для входной строки верните процент букв английского алфавита, присутствующих в строке.

• Ответ может быть в процентах или в десятичной форме.

• Входная строка может иметь прописные и строчные буквы, а также знаки препинания. Однако вы можете предположить, что в них нет диакритических знаков или акцентуаций.

Контрольные примеры

вход

"Did you put your name in the Goblet of Fire, Harry?" he asked calmly.

Некоторые действительные выводы

77%, 76.9, 0.7692

Входные данные:

The quick brown fox jumps over the lazy dog

Все действительные выводы:

100%, 100, 1

Ожидаемый результат для "@#$%^&*?!"и ""составляет 0.

Python 3 , 42 байта

lambda s:len({*s.upper()}-{*s.lower()})/26

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

Мы отфильтровываем все неалфавитные символы из строки, беря (устанавливая) разницу между прописными и строчными представлениями. Затем мы берем длину и делим на 26.

Python 3 , 46 байт

lambda s:sum(map(str.isalpha,{*s.lower()}))/26

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

Подсчитайте уникальные алфавитные (строчные) символы и разделите на 26. В Python 2 потребуется еще 3 символа; два для перехода {*...}на set(...), и один для создания 26 поплавка:, 26.чтобы избежать разделения пола.

Python 3 , 46 байт

lambda s:sum('`'<c<'{'for c in{*s.lower()})/26

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

Та же самая длина, по существу та же самая как предыдущий, но без "встроенного" строкового метода.

MATL , 8 байт

2Y2jkmYm

Попробуйте это на MATL Online

объяснение

2Y2    % Predefined literal for 'abcdefghijklmnopqrstuvwxyz'
j      % Explicitly grab input as a string
k      % Convert to lower-case
m      % Check for membership of the alphabet characters in the string. 
       % Results in a 26-element array with a 1 where a given character in 
       % the alphabet string was present in the input and a 0 otherwise
Ym     % Compute the mean of this array to yield the percentage as a decimal
       % Implicitly display the result

Октава / MATLAB, 33 байта

@(s)mean(any(65:90==upper(s)',1))

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

объяснение

@(s)                               % Anonymous function with input s: row vector of chars
             65:90                 % Row vector with ASCII codes of uppercase letters
                    upper(s)       % Input converted to uppercase
                            '      % Transform into column vector
                  ==               % Equality test, element-wise with broadcast. Gives a
                                   % matrix containing true and false
         any(                ,1)   % Row vector containing true for columns that have at
                                   % least one entry with value true
    mean(                       )  % Mean

05AB1E , 8 7 6 байт

lASåÅA

-1 байт благодаря @LuisMendo .

Попробуйте онлайн или проверьте еще несколько тестов .

Альтернатива 6 байтов предоставлена @Grimy :

láÙg₂/

Попробуйте онлайн или проверьте еще несколько тестов .

Обе программы выводятся как десятичные.

Объяснение:

l       # Convert the (implicit) input-string to lowercase
 AS     # Push the lowercase alphabet as character-list
   å    # Check for each if it's in the lowercase input-string
        # (1 if truthy; 0 if falsey)
    ÅA  # Get the arithmetic mean of this list
        # (and output the result implicitly)

l       # Convert the (implicit) input-string to lowercase
 á      # Only leave the letters in this lowercase string
  Ù     # Uniquify it
   g    # Get the amount of the unique lowercase letters by taking the length
    ₂/  # Divide this by 26
        # (and output the result implicitly)

C # (интерактивный компилятор Visual C #) , 56 49 байт

a=>a.ToUpper().Distinct().Count(x=>x>64&x<91)/26f

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

-6 байт благодаря innat3

APL (Dyalog Extended) , 10 байтов ^SBCS

Функция анонимного молчаливого префикса. Возвращает десятичную дробь.

26÷⍨∘≢⎕A∩⌈

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

⌈ верхний регистр

⎕A∩ пересечение с прописной A lphabet

≢ длина счета

∘ тогда

26÷⍨ разделить на двадцать шесть

Perl 6 , 27 24 байта

-3 байта благодаря nwellnhof

*.uc.comb(/<:L>/).Set/26

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

Утилиты Bash и Gnu ( 81 78 68 60 42 байта)

bc -l<<<`grep -io [a-z]|sort -fu|wc -l`/26

-8 байт благодаря @wastl

-18 байт благодаря Науэлю, использующему некоторые уловки, которых я не знал:

• sort -fи grep -iигнорировать регистр
• sort -u это замена для | uniq

K (ок) , 19 15 байт

Решение:

1%26%+/26>?97!_

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

Объяснение:

Преобразуйте входные данные в строчные, по модулю 97 («az» - это 97-122 в ASCII, по модулю 97 - от 0 до 25), возьмите уникальные, суммируйте результаты, которые меньше, чем 26, и преобразуйте в процент от 26.

1%26%+/26>?97!_ / the solution
              _ / lowercase
           97!  / modulo (!) 97
          ?     / distinct
       26>      / is 26 greater than this?
     +/         / sum (+) over (/)
  26%           / 26 divided by ...
1%              / 1 divided by ...

Заметки:

• -1 байт благодаря ngn, 1-%[;26]=>1-1%26%
• -3 байта, вдохновленные ngn #(!26)^=>+/26>?

PowerShell , 55 52 байта

($args|% *per|% t*y|sort|gu|?{$_-in65..90}).count/26

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

Первая попытка, все еще пробуя случайные идеи

РЕДАКТИРОВАТЬ: @Veskah указал ToUpper сохраняет байт из-за диапазона номеров, также удалены лишние ()и пробел

Расширение:
($args|% ToUpper|% ToCharArray|sort|get-unique|where{$_-in 65..90}).count/26

Изменяет строку на все строчные буквы в верхнем регистре, расширяет массив, сортирует элементы и выбирает уникальные буквы (gu требует отсортированного ввода), сохраняя только символы ascii от 97 до 122 (от a до z) от 65 до 90 (от A до Z), подсчитать сумму и разделить на 26 для десятичного вывода

R , 47 байт

function(x)mean(65:90%in%utf8ToInt(toupper(x)))

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

Преобразует в верхний регистр, затем в кодовые точки ASCII и проверяет значения 65:90, соответствующие A: Z.

Сетчатка 0.8.2 , 45 байт

T`Llp`ll_
+`(.)(.*\1)
$2
.
100$*
^
13$*
.{26}

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

T`Llp`ll_

Строчные буквы и удаление знаков препинания.

+`(.)(.*\1)
$2

Дедуплицировать.

.
100$*

Умножьте на 100.

^
13$*

Добавить 13.

.{26}

Целочисленное деление на 26 и преобразование в десятичное число.

APL (Dyalog Extended) , 8 байт

⌹∘≤⍨⎕A∊⌈

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

слабо на основе ответа Адама

⌈ верхний регистр

⎕A∊логическое значение (0 или 1) вектор длины 26 , который указывает на буквы английского A lphabet находятся в строке

⌹∘≤⍨ среднее арифметическое, то есть матричное деление аргумента и вектор все-1 одинаковой длины

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

Ｉ∕ＬΦβ№↧θι²⁶

Попробуйте онлайн! Ссылка на подробную версию кода. Вывод в виде десятичного числа (или 1для панграмм). Объяснение:

  Ｌ         Length of
    β       Lowercase alphabet
   Φ        Filtered on
     №      Count of
        ι   Current letter in
      ↧     Lowercased
       θ    Input
 ∕          Divided by
         ²⁶ Literal 26
Ｉ           Cast to string
            Implicitly printed

Пакет, 197 байт

@set/ps=
@set s=%s:"=%
@set n=13
@for %%c in (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)do @call set t="%%s:%%c=%%"&call:c
@cmd/cset/an/26
@exit/b
:c
@if not "%s%"==%t% set/an+=100

Принимает ввод в STDIN и выводит округленный процент. Объяснение:

@set/ps=

Введите строку.

@set s=%s:"=%

Убирайте кавычки, потому что это головная боль в Batch.

@set n=13

Начните с половины буквы для округления.

@for %%c in (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)do @call set t="%%s:%%c=%%"&call:c

Удалить каждую букву по очереди из строки. Вызовите подпрограмму, чтобы проверить, изменилось ли что-нибудь из-за способа, которым пакетный анализирует переменные.

@cmd/cset/an/26

Рассчитать результат в процентах.

@exit/b
:c

Начало подпрограммы.

@if not "%s%"=="%t%" set/an+=100

Если удаление буквы изменило строку, увеличьте количество букв.

Пепе , 155 138 байт

rEeEeeeeeEREeEeEEeEeREERrEEEEErEEEeReeReRrEeeEeeeeerEEEEREEeRERrErEErerREEEEEeREEeeRrEreerererEEEEeeerERrEeeeREEEERREeeeEEeEerRrEEEEeereEE

Попробуйте онлайн! Вывод в десятичной форме.

Объяснение:

rEeEeeeeeE REeEeEEeEe # Push 65 -> (r), 90 -> (R)
REE # Create loop labeled 90 // creates [65,66,...,89,90]
  RrEEEEE # Increment (R flag: preserve the number) in (r)
  rEEEe # ...then move the pointer to the last
Ree # Do this while (r) != 90

Re # Pop 90 -> (R)
RrEeeEeeeee rEEEE # Push 32 and go to first item -> (r)
REEe # Push input -> (R)
RE RrE # Push 0 on both stacks, (r) prepend 0
rEE # Create loop labeled 0 // makes input minus 32, so the
    # lowercase can be accepted, since of rEEEEeee (below)
  re # Pop 0 -> (r)
  rREEEEEe REEee # Push item of (R) minus 32, then go to next item 
  RrE # Push 0 -> (R)
ree # Do while (R) != 0

rere # Pop 0 & 32 -> (r)
rEEEEeee # Remove items from (r) that don't occur in (R)
         # Remove everything from (r) except the unique letters
rE # Push 0 -> (r)
RrEeee # Push reverse pointer pos -> (r)
REEEE # Move pointer to first position -> (R)
RREeeeEEeEe # Push 26 -> (R)
rRrEEEEee reEE # Divide it and output it

K (ок) , 19 байт

1%26%26-#(!26)^97!_

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

J , 30 байт

26%~26-u:@(97+i.26)#@-.tolower

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

Retina , 57 46 35 байт

.
$L
[^a-z]

D`.
.
100*
^
13*
_{26}

-11 байт, вдохновленные трюком @Neil о добавлении унарных 13 перед делением .
Еще -11 байтов благодаря @Neil напрямую.
Округляет (правильно) до целого числа.

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

57 46 40 байтов версия, которая работает с десятичным выводом:

.
$L
[^a-z]

D`.
.
1000*
C`_{26}
-1`\B
.

Те же -11 байтов, а также дополнительные -6 байтов благодаря @Neil .

$0.1538$$\frac{4}{26}$15.315.4$\lfloor{\frac{1000 × \text{unique_letters}}{26}\rfloor}$

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

Объяснение:

Преобразовать все буквы в нижний регистр:

.
$L

Удалить все не-буквы:

[^a-z]

Унифицируйте все буквы:

D`.

Замените каждое уникальное письмо 1000 подчеркиванием:

.
1000*

Подсчитайте, сколько раз 26 соседних подчеркиваний помещаются в него:

C`_{26}

Вставьте точку в правильном месте:

-1`\B
.

Java 8, 62 59 байт

s->s.map(c->c&95).distinct().filter(c->c%91>64).count()/26.

-3 байта благодаря @ OlivierGrégoire .

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

Объяснение:

s->                     // Method with IntStream as parameter and double return-type
  s.map(c->c&95)        //  Convert all letters to uppercase
   .distinct()          //  Uniquify it
   .filter(c->c%91>64)  //  Only leave letters (unicode value range [65,90])
   .count()             //  Count the amount of unique letters left
    /26.                //  Divide it by 26.0

Юлия 1,0 , 34 байта

s->sum('a':'z'.∈lowercase(s))/26

Использует векторизованную версию оператора ∈, проверяя наличие в строке всех символов в диапазоне от a до z. Затем суммирует полученный битовый массив и делит на общее количество возможных букв.

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

C 96 байтов

float f(char*s){int i=66,l[256]={};for(;*s;)l[1+*s++&~32]=1;for(;i<92;*l+=l[i++]);return*l/26.;}

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

Perl 5 -MList::Util=uniq -p , 24 байта

$_=uniq(lc=~/[a-z]/g)/26

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

Stax , 9 байт

░║üy$}╙+C

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

Желе , 8 байт

ŒuØAe€Æm

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

объяснение

Œu       | Convert to upper case
  ØAe€   | Check whether each capital letter is present, returning a list of 26 0s and 1s
      Æm | Mean

JavaScript (Node.js) , 45 байт

s=>~-s.match(/$|([a-z])(?!.*\1)/ig).length/26

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

JavaScript (Node.js) , 47 байт

s=>(s.match(/([a-z])(?!.*\1)/ig)||[]).length/26

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

Python 3 , 51 49 байт

51 -> 49 байтов, благодаря alexz02

lambda s:len({*filter(str.isalpha,s.lower())})/26

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

Japt , 9 байт

;CoU Ê/26

Попытайся

;CoU Ê/26     :Implicit input of string U
;C            :Lowercase alphabet
  oU          :Remove the characters not included in U, case insensitive
     Ê        :Length
      /26     :Divide by 26

Python 2 , 57 байт

lambda i:len(set(o for o in i.lower()if o.isalpha()))/26.

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

Немного длиннее, чем ответ Python 3 от ArBo, но в любом случае опубликован как другой подход в Python 2.

Рубин -n , 38 34 байта

-4 байта от @historcrat!

p (?A..?Z).count{|c|~/#{c}/i}/26.0

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

C, 95 байтов

f(char*s){int a[256]={},z;while(*s)a[*s++|32]=1;for(z=97;z<'z';*a+=a[z++]);return(*a*100)/26;}

(примечание: округление вниз)

Альтернативная версия с десятичным возвращением (95 байт):

float f(char*s){int a[256]={},z;while(*s&&a[*s++|32]=1);for(z=97;z<'z';*a+=a[z++]);return*a/26.;}

Это заимствует некоторые из ответа @Steadybox.