Вступ

Скільки англійського алфавіту використовує даний рядок? У попередньому реченні використовується 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 # Interactive Compiler) , 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 and 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

К (оК) , 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

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

Перша спроба, як і раніше намагаються випадкові ідеї

EDIT: @Veskah вказав, що ToUpper економить байт завдяки діапазону чисел, а також видаляє зайві ()та пробіл

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

Змінює рядок на всі нижні регістри, розширюється на масив, сортує елементи та вибирає унікальні літери (гу потребує впорядкованому введенні), зберігає лише символи значення 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

Видаляйте кожну букву по черзі з рядка. Запустіть підпрограму, щоб перевірити, чи змінилося щось через те, як Batch аналізує змінні.

@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 (oK) , 19 байт

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

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

J , 30 байт

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

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

Сітківка , 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. Потім підсумовує отриманий BitArray і ділиться на загальну кількість можливих літер.

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

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

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

Стакс , 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.