Introdução

Quanto do alfabeto inglês usa uma determinada string? A frase anterior usa 77%. Possui 20 letras únicas (howmucftenglisapbdvr) e 20/26 ± 0,77.

Desafio

Para uma sequência de entrada, retorne a porcentagem de letras do alfabeto inglês presente na sequência.

• A resposta pode estar em porcentagem ou em forma decimal.

• A sequência de entrada pode ter letras maiúsculas e minúsculas, além de pontuação. No entanto, você pode assumir que eles não têm sinais diacríticos ou acentuados.

Casos de teste

Entrada

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

Algumas saídas válidas

77%, 76.9, 0.7692

Entrada:

The quick brown fox jumps over the lazy dog

Todas as saídas válidas:

100%, 100, 1

A saída esperada para "@#$%^&*?!"e ""é 0.

Python 3 , 42 bytes

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

Experimente online!

Nós filtramos todos os caracteres não alfabéticos da string, assumindo a diferença (definida) das representações maiúsculas e minúsculas. Então, pegamos o comprimento e dividimos por 26.

Python 3 , 46 bytes

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

Experimente online!

Conte os caracteres alfabéticos (minúsculos) exclusivos e divida por 26. No Python 2, seriam necessários mais 3 caracteres; dois para mudar {*...}para set(...)e um para fazer 26 flutuar:, 26.para evitar a divisão do piso.

Python 3 , 46 bytes

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

Experimente online!

Mesmo comprimento, essencialmente o mesmo que o anterior, mas sem o método de string "interno".

MATL , 8 bytes

2Y2jkmYm

Experimente no MATL Online

Explicação

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

Oitava / MATLAB, 33 bytes

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

Experimente online!

Explicação

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

lASåÅA

-1 byte graças a @LuisMendo .

Experimente online ou verifique mais alguns casos de teste .

Alternativa de 6 bytes fornecida pelo @Grimy :

láÙg₂/

Experimente online ou verifique mais alguns casos de teste .

Ambos os programas saem como decimal.

Explicação:

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 # (compilador interativo do Visual C #) , 56 49 bytes

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

Experimente online!

-6 bytes graças a innat3

APL (Dyalog Extended) , ^{SBCS de} 10 bytes

Função de prefixo tácito anônimo. Retorna a fração decimal.

26÷⍨∘≢⎕A∩⌈

Experimente online!

⌈ maiúscula

⎕A∩ interseção com o alfabeto A maiúsculo

≢ comprimento de registro

∘ então

26÷⍨ dividir por vinte e seis

Perl 6 , 27 24 bytes

-3 bytes graças a nwellnhof

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

Experimente online!

Utilitários Bash e Gnu ( 81 78 68 60 42 bytes)

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

-8 bytes graças a @wastl

-18 bytes graças a Nahuel usando alguns truques que eu não sabia:

• sort -fe grep -iignorar maiúsculas e minúsculas
• sort -u é um substituto para | uniq

K (oK) , 19 15 bytes

Solução:

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

Experimente online!

Explicação:

Converter entrada em minúscula, módulo 97 ("az" é 97-122 em ASCII, módulo 97 fornece 0-25), obter exclusivo, resumir resultados inferiores a 26 e converter para a porcentagem de 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 ...

Notas:

• -1 bytes graças a ngn, 1-%[;26]=>1-1%26%
• -3 bytes inspirados em ngn #(!26)^=>+/26>?

PowerShell , 55 52 bytes

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

Experimente online!

Primeira tentativa, ainda tentando idéias aleatórias

EDIT: @Veskah apontou ToUpper salva um byte devido ao intervalo de números, também removido extra ()e um espaço

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

Altera a string para todas as maiúsculas, expande para uma matriz, classifica os elementos e seleciona as letras únicas (gu precisa de entrada classificada), mantém apenas caracteres do valor ascii 97 a 122 (a a z) 65 a 90 (A a Z), conte o total e divida por 26 para a saída decimal

R , 47 bytes

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

Experimente online!

Converte em maiúsculas e depois em pontos de código ASCII e verifica os valores 65:90 correspondentes a A: Z.

Retina 0.8.2 , 45 bytes

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

Experimente online! O link inclui casos de teste. Explicação:

T`Llp`ll_

Letras minúsculas e excluir pontuação.

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

Desduplicar.

.
100$*

Multiplique por 100.

^
13$*

Adicione 13.

.{26}

Inteiro divida por 26 e converta em decimal.

APL (Dyalog Extended) , 8 bytes

⌹∘≤⍨⎕A∊⌈

Experimente online!

vagamente baseado na resposta de Adám

⌈ maiúscula

⎕A∊booleano (0 ou 1) de vector de comprimento igual a 26, indicando que as letras do Inglês Um lphabet estão na cadeia

⌹∘≤⍨ média aritmética, isto é, divisão matricial do argumento e um vetor all-1 do mesmo comprimento

Carvão , 11 bytes

Ｉ∕ＬΦβ№↧θι²⁶

Experimente online! Link é a versão detalhada do código. A saída é decimal (ou 1para pangramas). Explicação:

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

Lote, 197 bytes

@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

Aceita STDIN e gera uma porcentagem arredondada. Explicação:

@set/ps=

Insira a string.

@set s=%s:"=%

Tira citações, porque elas são uma dor de cabeça para lidar com o Lote.

@set n=13

Comece com meia letra para fins de arredondamento.

@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

Exclua cada letra sucessivamente da string. Invoque a sub-rotina para verificar se alguma coisa mudou, devido à maneira como o Lote analisa variáveis.

@cmd/cset/an/26

Calcule o resultado como uma porcentagem.

@exit/b
:c

Início da sub-rotina.

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

Se a exclusão de uma letra alterou a sequência, aumente a contagem de letras.

Pepe , 155 138 bytes

rEeEeeeeeEREeEeEEeEeREERrEEEEErEEEeReeReRrEeeEeeeeerEEEEREEeRERrErEErerREEEEEeREEeeRrEreerererEEEEeeerERrEeeeREEEERREeeeEEeEerRrEEEEeereEE

Experimente online! A saída está na forma decimal.

Explicação:

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 bytes

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

Experimente online!

J , 30 bytes

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

Experimente online!

Retina , 57 46 35 bytes

.
$L
[^a-z]

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

-11 bytes, inspirando-se no truque do @Neil de adicionar 13 unários antes de dividir .
Mais -11 bytes graças a @Neil diretamente.
Arredonda (corretamente) para um número inteiro inteiro.

Experimente online.

57 46 versão de 40 bytes que funciona com saída decimal:

.
$L
[^a-z]

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

Mesmos -11 bytes, além de -6 bytes adicionais, graças ao @Neil .

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

Experimente online.

Explicação:

Converta todas as letras em minúsculas:

.
$L

Remova todas as não letras:

[^a-z]

Unifique todas as letras:

D`.

Substitua cada letra exclusiva por 1000 sublinhados:

.
1000*

Conte a quantidade de vezes que 26 sublinhados adjacentes se encaixam nele:

C`_{26}

Insira um ponto no local correto:

-1`\B
.

Java 8, 62 59 bytes

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

-3 bytes graças a @ OlivierGrégoire .

Experimente online.

Explicação:

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

Usa a versão vetorizada do operador,, verificando a contenção na cadeia para todos os caracteres no intervalo de a a z. Em seguida, soma o BitArray resultante e divide pelo número total de letras possíveis.

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

Experimente online!

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

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

Experimente online!

Stax , 9 bytes

░║üy$}╙+C

Execute e depure

Geléia , 8 bytes

ŒuØAe€Æm

Experimente online!

Explicação

Œ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

Experimente online!

JavaScript (Node.js) , 47 bytes

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

Experimente online!

Python 3 , 51 49 bytes

51 -> 49 bytes, graças a alexz02

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

Experimente online!

Japonês , 9 bytes

;CoU Ê/26

Tente

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

Experimente online!

Um pouco mais do que a resposta do Python 3 do ArBo, mas postada como uma abordagem diferente no Python 2 de qualquer maneira.

Ruby -n , 38 34 bytes

-4 bytes de @historcrat!

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

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

(nota: arredonda para baixo)

Versão alternativa com retorno decimal (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.;}

Isso empresta parte da resposta do @Steadybox '.