Wprowadzenie

Ile alfabetu angielskiego używa dany ciąg? Poprzednie zdanie używa 77%. Ma 20 unikalnych liter (howmucftenglisapbdvr) i 20/26 ≃ 0,77.

Wyzwanie

W przypadku ciągu wejściowego zwróć procent liter alfabetu angielskiego obecnych w ciągu.

• Odpowiedź może być procentowa lub dziesiętna.

• Łańcuch wejściowy może zawierać wielkie i małe litery, a także znaki interpunkcyjne. Można jednak założyć, że nie mają znaków diakrytycznych ani znaków akcentowanych.

Przypadki testowe

Wkład

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

Niektóre prawidłowe dane wyjściowe

77%, 76.9, 0.7692

Wkład:

The quick brown fox jumps over the lazy dog

Wszystkie ważne dane wyjściowe:

100%, 100, 1

Oczekiwany wynik dla "@#$%^&*?!"i ""wynosi 0.

Python 3 , 42 bajty

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

Wypróbuj online!

Filtrujemy wszystkie znaki niealfabetyczne z ciągu, biorąc (ustawioną) różnicę reprezentacji wielkich i małych liter. Następnie bierzemy długość i dzielimy przez 26.

Python 3 , 46 bajtów

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

Wypróbuj online!

Policz unikalne znaki alfabetyczne (małe litery) i podziel przez 26. W Pythonie 2 wymagałoby to 3 dodatkowych znaków; dwa do zmiany {*...}na set(...)i jeden do uczynienia 26 pływakiem:, 26.aby uniknąć podziału podłogi.

Python 3 , 46 bajtów

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

Wypróbuj online!

Ta sama długość, zasadniczo taka sama jak poprzednia, ale bez „wbudowanej” metody łańcuchowej.

MATL , 8 bajtów

2Y2jkmYm

Wypróbuj w MATL Online

Wyjaśnienie

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

Octave / MATLAB, 33 bajty

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

Wypróbuj online!

Wyjaśnienie

@(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 bajtów

lASåÅA

-1 bajt dzięki @LuisMendo .

Wypróbuj online lub sprawdź kilka innych przypadków testowych .

6 bajtów alternatywnych dostarczonych przez @Grimy :

láÙg₂/

Wypróbuj online lub sprawdź kilka innych przypadków testowych .

Oba programy wyświetlają dane w postaci dziesiętnej.

Wyjaśnienie:

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 # (interaktywny kompilator Visual C #) , 56 49 bajtów

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

Wypróbuj online!

-6 bajtów dzięki innat3

APL (Dyalog Extended) , 10 bajtów ^SBCS

Anonimowa ukryta funkcja prefiksu. Zwraca ułamek dziesiętny.

26÷⍨∘≢⎕A∩⌈

Wypróbuj online!

⌈ duże litery

⎕A∩ skrzyżowanie z dużych liter A lphabet

≢ długość całkowita

∘ następnie

26÷⍨ podzielić przez dwadzieścia sześć

Perl 6 , 27 24 bajtów

-3 bajty dzięki nwellnhof

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

Wypróbuj online!

Narzędzia Bash i Gnu ( 81 78 68 60 42 bajtów)

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

-8 bajtów dzięki @wastl

-18 bajtów dzięki Nahuelowi, który wykorzystał kilka sztuczek, których nie znałem:

• sort -fi grep -izignoruj ​​wielkość liter
• sort -u jest zamiennikiem dla | uniq

K (oK) , 19 15 bajtów

Rozwiązanie:

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

Wypróbuj online!

Wyjaśnienie:

Konwertuj dane wejściowe na małe litery, modulo 97 („az” to 97-122 w ASCII, modulo 97 daje 0-25), weź unikalne, sumujące wyniki, które są mniejsze niż 26, i konwertuj na procent 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 ...

Uwagi:

• -1 bajtów dzięki ngn, 1-%[;26]=>1-1%26%
• -3 bajty inspirowane przez ngn #(!26)^=>+/26>?

PowerShell , 55 52 bajtów

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

Wypróbuj online!

Pierwsza próba, wciąż próbowanie przypadkowych pomysłów

EDYCJA: @Veskah wskazał, że ToUpper zapisuje bajt ze względu na zakres liczb, również usunął dodatkowe ()i spację

Ekspansja:
($args|% ToUpper|% ToCharArray|sort|get-unique|where{$_-in 65..90}).count/26

Zmienia ciąg na wszystkie małe litery, rozwija się do tablicy, sortuje elementy i wybiera unikalne litery (gu wymaga posortowanych danych wejściowych), zachowuje tylko znaki o wartości ascii od 97 do 122 (od a do z) od 65 do 90 (od A do Z), policz sumę i podziel przez 26 dla wyniku dziesiętnego

R , 47 bajtów

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

Wypróbuj online!

Konwertuje na wielkie litery, a następnie na punkty kodowe ASCII i sprawdza wartości 65:90 odpowiadające A: Z.

Retina 0.8.2 , 45 bajtów

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

Wypróbuj online! Link zawiera przypadki testowe. Wyjaśnienie:

T`Llp`ll_

Małe litery i usuń znaki interpunkcyjne.

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

Deduplikacja.

.
100$*

Pomnóż przez 100.

^
13$*

Dodaj 13.

.{26}

Liczba całkowita dzieli przez 26 i przelicza na dziesiętne.

APL (Dyalog Extended) , 8 bajtów

⌹∘≤⍨⎕A∊⌈

Wypróbuj online!

luźno oparty na odpowiedzi Adáma

⌈ duże litery

⎕A∊wektor boolowski (0 lub 1) o długości 26 wskazujący, które litery alfabetu angielskiego A znajdują się w ciągu

⌹∘≤⍨ średnia arytmetyczna, tj. podział macierzy argumentu i wektor all-1 o tej samej długości

Węgiel drzewny , 11 bajtów

Ｉ∕ＬΦβ№↧θι²⁶

Wypróbuj online! Link jest do pełnej wersji kodu. Dane wyjściowe są w postaci dziesiętnej (lub w 1przypadku pangrams). Wyjaśnienie:

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

Partia, 197 bajtów

@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

Pobiera dane wejściowe na STDIN i generuje zaokrąglony procent. Wyjaśnienie:

@set/ps=

Wpisz ciąg.

@set s=%s:"=%

Rozwiń cytaty, ponieważ są to bóle głowy w Batch.

@set n=13

Zacznij od połowy litery do celów zaokrąglania.

@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

Usuń kolejno każdą literę z ciągu. Wywołaj podprogram, aby sprawdzić, czy coś się zmieniło, ze względu na sposób, w jaki Batch analizuje zmienne.

@cmd/cset/an/26

Oblicz wynik jako procent.

@exit/b
:c

Rozpoczęcie podprogramu.

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

Jeśli usunięcie litery zmieniło ciąg, zwiększ liczbę liter.

Pepe , 155 138 bajtów

rEeEeeeeeEREeEeEEeEeREERrEEEEErEEEeReeReRrEeeEeeeeerEEEEREEeRERrErEErerREEEEEeREEeeRrEreerererEEEEeeerERrEeeeREEEERREeeeEEeEerRrEEEEeereEE

Wypróbuj online! Dane wyjściowe są w postaci dziesiętnej.

Wyjaśnienie:

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 bajtów

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

Wypróbuj online!

J , 30 bajtów

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

Wypróbuj online!

Retina , 57 46 35 bajtów

.
$L
[^a-z]

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

-11 bajtów inspirowanych sztuczką @Neil polegającą na dodaniu jednych 13 przed podzieleniem .
Kolejne -11 bajtów dzięki @Neil bezpośrednio.
Zaokrągla (poprawnie) do całej liczby całkowitej.

Wypróbuj online.

57 46 40 bajtowa wersja, która działa z wyjściem dziesiętnym:

.
$L
[^a-z]

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

Same -11 bajtów, a także dodatkowe -6 bajtów dzięki @Neil .

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

Wypróbuj online.

Wyjaśnienie:

Konwertuj wszystkie litery na małe:

.
$L

Usuń wszystkie nie-litery:

[^a-z]

Ujednolic wszystkie litery:

D`.

Zastąp każdą unikalną literę 1000 podkreślnikami:

.
1000*

Policz, ile razy pasuje do niego 26 sąsiadujących podkreślników:

C`_{26}

Wstaw kropkę we właściwym miejscu:

-1`\B
.

Java 8, 62 59 bajtów

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

-3 bajty dzięki @ OlivierGrégoire .

Wypróbuj online.

Wyjaśnienie:

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

Julia 1.0 , 34 bajty

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

Używa wektoryzowanej wersji operatora ∈, sprawdzając zawartość ciągu w przypadku wszystkich znaków z zakresu od a do z. Następnie sumuje wynikowy BitArray i dzieli przez całkowitą liczbę możliwych liter.

Wypróbuj online!

C, 96 bajtów

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.;}

Wypróbuj online!

Perl 5 -MList::Util=uniq -p , 24 bajtów

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

Wypróbuj online!

Stax , 9 bajtów

░║üy$}╙+C

Uruchom i debuguj

Galaretka , 8 bajtów

ŒuØAe€Æm

Wypróbuj online!

Wyjaśnienie

Œ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 bajtów

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

Wypróbuj online!

JavaScript (Node.js) , 47 bajtów

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

Wypróbuj online!

Python 3 , 51 49 bajtów

51 -> 49 bajtów, dzięki alexz02

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

Wypróbuj online!

Japt , 9 bajtów

;CoU Ê/26

Spróbuj

;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 bajtów

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

Wypróbuj online!

Trochę dłużej niż odpowiedź Python 3 z ArBo, ale opublikowana jako inne podejście w Pythonie 2.

Rubinowy -n , 38 34 bajtów

-4 bajty od @historcrat!

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

Wypróbuj online!

C, 95 bajtów

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;}

(uwaga: zaokrągla w dół)

Alternatywna wersja ze znakiem dziesiętnym (95 bajtów):

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.;}

Pożycza to część odpowiedzi @Steadybox.