introduzione

Quanto dell'alfabeto inglese utilizza una determinata stringa? La frase precedente utilizza il 77%. Ha 20 lettere uniche (howmucftenglisapbdvr) e 20/26 ≃ 0,77.

Sfida

Per una stringa di input, restituisce la percentuale di lettere dell'alfabeto inglese presente nella stringa.

• La risposta può essere in percentuale o in forma decimale.

• La stringa di input può contenere lettere maiuscole e minuscole, nonché punteggiatura. Comunque puoi presumere che non abbiano segni diacritici o accentuati.

Casi test

Ingresso

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

Alcuni output validi

77%, 76.9, 0.7692

Ingresso:

The quick brown fox jumps over the lazy dog

Tutte le uscite valide:

100%, 100, 1

L'output previsto per "@#$%^&*?!"e ""è 0.

Python 3 , 42 byte

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

Provalo online!

Filtriamo tutti i caratteri non alfabetici fuori dalla stringa prendendo la differenza (imposta) delle rappresentazioni maiuscole e minuscole. Quindi, prendiamo la lunghezza e dividiamo per 26.

Python 3 , 46 byte

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

Provalo online!

Conta i caratteri alfabetici (minuscoli) unici e dividi per 26. In Python 2 richiederebbe altri 3 caratteri; due per passare {*...}a set(...), e uno per rendere 26 un galleggiante:, 26.per evitare la divisione del pavimento.

Python 3 , 46 byte

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

Provalo online!

Stessa lunghezza, sostanzialmente uguale alla precedente, ma senza metodo di stringa "incorporato".

MATL , 8 byte

2Y2jkmYm

Provalo su MATL Online

Spiegazione

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 byte

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

Provalo online!

Spiegazione

@(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 byte

lASåÅA

-1 byte grazie a @LuisMendo .

Provalo online o verifica alcuni altri casi di test .

Alternativa a 6 byte fornita da @Grimy :

láÙg₂/

Provalo online o verifica alcuni altri casi di test .

Entrambi i programmi vengono emessi come decimali.

Spiegazione:

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 # (compilatore interattivo Visual C #) , 56 49 byte

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

Provalo online!

-6 byte grazie a innat3

APL (Dyalog Extended) , 10 byte ^SBCS

Funzione prefisso tacito anonimo. Restituisce la frazione decimale.

26÷⍨∘≢⎕A∩⌈

Provalo online!

⌈ maiuscolo

⎕A∩ intersezione con l' alfabeto A maiuscolo

≢ lunghezza del conteggio

∘ poi

26÷⍨ dividere per ventisei

Perl 6 , 27 24 byte

-3 byte grazie a nwellnhof

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

Provalo online!

Utilità Bash e Gnu ( 81 78 68 60 42 byte)

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

-8 byte grazie a @wastl

-18 byte grazie a Nahuel usando alcuni trucchi che non sapevo:

• sort -fe grep -iignora il caso
• sort -u è un sostituto di | uniq

K (oK), 19 15 bytes

Solution:

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

Try it online!

Explanation:

Convert input to lowercase, modulo 97 ("a-z" is 97-122 in ASCII, modulo 97 gives 0-25), take unique, sum up results that are lower than 26, and convert to the percentage of 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 ...

Notes:

• -1 bytes thanks to ngn, 1-%[;26] => 1-1%26%
• -3 bytes inspired by ngn #(!26)^ => +/26>?

PowerShell, 55 52 bytes

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

Try it online!

First attempt, still trying random ideas

EDIT: @Veskah pointed out ToUpper saves a byte due to the number range, also removed extra () and a space

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

Changes string to all loweruppercase, expands to an array, sorts the elements and selects the unique letters (gu needs sorted input), keep only characters of ascii value 97 to 122 (a to z) 65 to 90 (A to Z), count the total and divide by 26 for the decimal output

R, 47 bytes

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

Try it online!

Converts to upper case then to ASCII code-points, and checks for values 65:90 corresponding to A:Z.

Retina 0.8.2, 45 bytes

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

Try it online! Link includes test cases. Explanation:

T`Llp`ll_

Lowercase letters and delete punctuation.

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

Deduplicate.

.
100$*

Multiply by 100.

^
13$*

Add 13.

.{26}

Integer divide by 26 and convert to decimal.

APL (Dyalog Extended), 8 bytes

⌹∘≤⍨⎕A∊⌈

Try it online!

vagamente basato sulla risposta di Adám

⌈ maiuscolo

⎕A∊vettore booleano (0 o 1) della lunghezza 26 che indica quali lettere dell'inglese Alphabet are in the string

⌹∘≤⍨ media aritmetica, ovvero divisione matriciale dell'argomento e un vettore tutto-1 della stessa lunghezza

Carbone , 11 byte

Ｉ∕ＬΦβ№↧θι²⁶

Provalo online! Il collegamento è alla versione dettagliata del codice. L'output è un decimale (o 1per i pangrammi). Spiegazione:

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

Lotto, 197 byte

@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

Accetta input su STDIN e genera una percentuale arrotondata. Spiegazione:

@set/ps=

Inserisci la stringa.

@set s=%s:"=%

Rimuovi le virgolette, perché sono un mal di testa da affrontare in Batch.

@set n=13

Inizia con mezza lettera a scopo di arrotondamento.

@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

Elimina ogni lettera a turno dalla stringa. Richiamare la subroutine per verificare se qualcosa è cambiato, a causa del modo in cui Batch analizza le variabili.

@cmd/cset/an/26

Calcola il risultato in percentuale.

@exit/b
:c

Inizio della subroutine.

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

Se l'eliminazione di una lettera ha modificato la stringa, incrementa il conteggio delle lettere.

Pepe , 155 138 byte

rEeEeeeeeEREeEeEEeEeREERrEEEEErEEEeReeReRrEeeEeeeeerEEEEREEeRERrErEErerREEEEEeREEeeRrEreerererEEEEeeerERrEeeeREEEERREeeeEEeEerRrEEEEeereEE

Provalo online! L'output è in forma decimale.

Spiegazione:

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 byte

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

Provalo online!

J , 30 byte

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

Provalo online!

Retina , 57 46 35 byte

.
$L
[^a-z]

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

-11 byte prendendo ispirazione dal trucco di @Neil di aggiungere unario 13 prima di dividere .
Altri -11 byte grazie a @Neil direttamente.
Arrotonda (correttamente) a un intero.

Provalo online.

57 46 versione da 40 byte che funziona con output decimale:

.
$L
[^a-z]

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

Stessi -11 byte e altri -6 byte grazie a @Neil .

Emette un decimale ^† troncato dopo la virgola ( ^† ie$0.1538$ ($\frac{4}{26}$) is output as 15.3 instead of 15.4). This is done by calculating $\lfloor{\frac{1000 × \text{unique_letters}}{26}\rfloor}$ and then inserting the decimal dot manually.

Try it online.

Explanation:

Convert all letters to lowercase:

.
$L

Remove all non-letters:

[^a-z]

Uniquify all letters:

D`.

Replace every unique letter with 1000 underscores:

.
1000*

Count the amount of times 26 adjacent underscores fit into it:

C`_{26}

Insert a dot at the correct place:

-1`\B
.

Java 8, 62 59 bytes

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

-3 bytes thanks to @OlivierGrégoire.

Try it online.

Explanation:

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 bytes

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

Uses the vectorized version of the ∈ operator, checking containment in the string for all characters in the range from a to z. Then sums over the resulting BitArray and divides by total number of possible letters.

Try it online!

C, 96 bytes

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

Try it online!

Perl 5 -MList::Util=uniq -p, 24 bytes

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

Try it online!

Stax, 9 bytes

░║üy$}╙+C

Run and debug it

Jelly, 8 bytes

ŒuØAe€Æm

Try it online!

Explanation

Œ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 bytes

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

Try it online!

JavaScript (Node.js), 47 bytes

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

Try it online!

Python 3, 51 49 bytes

51 -> 49 bytes, thanks to alexz02

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

Try it online!

Japt, 9 bytes

;CoU Ê/26

Try it

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

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

Try it online!

A bit longer than the Python 3 answer from ArBo but posted as a different approach in Python 2 anyway.

Ruby -n, 38 34 bytes

-4 bytes from @historcrat!

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

Try it online!

C, 95 bytes

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

(note: rounds down)

Alternate decimal-returning version (95 bytes):

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

This borrows some from @Steadybox' answer.