Introducción

¿Qué parte del alfabeto inglés usa una cadena dada? La oración anterior usa 77%. Tiene 20 letras únicas (howmucftenglisapbdvr) y 20/26 ≃ 0.77.

Reto

Para una cadena de entrada, devuelva el porcentaje de letras del alfabeto inglés presente en la cadena.

• La respuesta puede ser en porcentaje o en forma decimal.

• La cadena de entrada puede tener mayúsculas y minúsculas, así como signos de puntuación. Sin embargo, puede suponer que no tienen signos diacríticos o caracteres acentuados.

Casos de prueba

Entrada

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

Algunas salidas válidas

77%, 76.9, 0.7692

Entrada:

The quick brown fox jumps over the lazy dog

Todas las salidas válidas:

100%, 100, 1

La salida esperada para "@#$%^&*?!"y ""es 0.

Python 3 , 42 bytes

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

Pruébalo en línea!

Filtramos todos los caracteres no alfabéticos fuera de la cadena tomando la diferencia (establecida) de las representaciones en mayúsculas y minúsculas. Luego, tomamos la longitud y la dividimos por 26.

Python 3 , 46 bytes

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

Pruébalo en línea!

Cuente los caracteres alfabéticos únicos (minúsculas) y divídalos entre 26. En Python 2, necesitaría 3 caracteres más; dos para cambiar {*...}a set(...), y uno para hacer un flotador 26., para evitar la división del piso.

Python 3 , 46 bytes

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

Pruébalo en línea!

Misma longitud, esencialmente la misma que la anterior, pero sin el método de cadena "incorporado".

MATL , 8 bytes

2Y2jkmYm

Pruébalo en MATL Online

Explicación

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

Octava / MATLAB, 33 bytes

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

Pruébalo en línea!

Explicación

@(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 gracias a @LuisMendo .

Pruébelo en línea o verifique algunos casos de prueba más .

Alternativa de 6 bytes proporcionada por @Grimy :

láÙg₂/

Pruébelo en línea o verifique algunos casos de prueba más .

Ambos programas salen como decimales.

Explicación:

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 interactivo de Visual C #) , 56 49 bytes

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

Pruébalo en línea!

-6 bytes gracias a innat3

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

Función de prefijo tácito anónimo. Devuelve la fracción decimal.

26÷⍨∘≢⎕A∩⌈

Pruébalo en línea!

⌈ mayúscula

⎕A∩ intersección con el alfabeto mayúscula A

≢ longitud de cuenta

∘ luego

26÷⍨ dividir entre veintiséis

Perl 6 , 27 24 bytes

-3 bytes gracias a nwellnhof

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

Pruébalo en línea!

Utilidades Bash y Gnu ( 81 78 68 60 42 bytes)

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

-8 bytes gracias a @wastl

-18 bytes gracias a Nahuel usando algunos trucos que no sabía:

• sort -fe grep -iignorar caso
• sort -u es un reemplazo para | uniq

K (oK) , 19 15 bytes

Solución:

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

Pruébalo en línea!

Explicación:

Convierta la entrada a minúsculas, módulo 97 ("az" es 97-122 en ASCII, el módulo 97 da 0-25), tome resultados únicos, resuman que sean inferiores a 26 y convierta al porcentaje 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 gracias a ngn, 1-%[;26]=>1-1%26%
• -3 bytes inspirados en ngn #(!26)^=>+/26>?

PowerShell , 55 52 bytes

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

Pruébalo en línea!

Primer intento, aún intentando ideas aleatorias

EDITAR: @Veskah señaló que ToUpper guarda un byte debido al rango de números, también se eliminó ()un espacio adicional

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

Cambia la cadena a todas las mayúsculas y minúsculas, se expande a una matriz, ordena los elementos y selecciona las letras únicas (gu necesita una entrada ordenada), mantiene solo caracteres de valor ASCII 97 a 122 (de la a a la z) 65 a 90 (de la A a la Z), cuenta el total y divide entre 26 para la salida decimal

R , 47 bytes

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

Pruébalo en línea!

Convierte a mayúsculas y luego a puntos de código ASCII, y comprueba los valores 65:90 correspondientes a A: Z.

Retina 0.8.2 , 45 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

T`Llp`ll_

Letras minúsculas y eliminar puntuación.

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

Deduplicar

.
100$*

Multiplica por 100.

^
13$*

Añadir 13.

.{26}

Entero dividir por 26 y convertir a decimal.

APL (Dyalog Extended) , 8 bytes

⌹∘≤⍨⎕A∊⌈

Pruébalo en línea!

basado libremente en la respuesta de Adám

⌈ mayúscula

⎕A∊vector booleano (0 o 1) de longitud 26 que indica qué letras del alfabeto inglés A están en la cadena

⌹∘≤⍨ media aritmética, es decir, división matricial del argumento y un vector todo-1 de la misma longitud

Carbón , 11 bytes

Ｉ∕ＬΦβ№↧θι²⁶

Pruébalo en línea! El enlace es a la versión detallada del código. La salida es como un decimal (o 1para pangramas). Explicación:

  Ｌ         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

Toma entrada en STDIN y genera un porcentaje redondeado. Explicación:

@set/ps=

Ingrese la cadena.

@set s=%s:"=%

Elimine las citas, porque son un dolor de cabeza para tratar en Batch.

@set n=13

Comience con media letra para redondear.

@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

Eliminar cada letra a su vez de la cadena. Invoque la subrutina para verificar si algo cambió, debido a la forma en que Batch analiza las variables.

@cmd/cset/an/26

Calcule el resultado como un porcentaje.

@exit/b
:c

Inicio de subrutina.

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

Si eliminar una letra cambió la cadena, incremente el recuento de letras.

Pepe , 155 138 bytes

rEeEeeeeeEREeEeEEeEeREERrEEEEErEEEeReeReRrEeeEeeeeerEEEEREEeRERrErEErerREEEEEeREEeeRrEreerererEEEEeeerERrEeeeREEEERREeeeEEeEerRrEEEEeereEE

Pruébalo en línea!La salida está en forma decimal.

Explicación:

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!_

Pruébalo en línea!

J , 30 bytes

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

Pruébalo en línea!

Retina , 57 46 35 bytes

.
$L
[^a-z]

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

-11 bytes inspirados en el truco de @Neil de agregar 13 unarios antes de dividir .
Otros -11 bytes gracias a @Neil directamente.
Redondea (correctamente) a un entero entero.

Pruébalo en línea.

57 46 Versión de 40 bytes que funciona con salida decimal:

.
$L
[^a-z]

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

Mismos -11 bytes, así como -6 bytes adicionales gracias a @Neil .

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

Pruébalo en línea.

Explicación:

Convierta todas las letras a minúsculas:

.
$L

Eliminar todas las no letras:

[^a-z]

Uniquificar todas las letras:

D`.

Reemplace cada letra única con 1000 guiones bajos:

.
1000*

Cuente la cantidad de veces que caben 26 guiones bajos adyacentes:

C`_{26}

Inserte un punto en el lugar correcto:

-1`\B
.

Java 8, 62 59 bytes

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

-3 bytes gracias a @ OlivierGrégoire .

Pruébalo en línea.

Explicación:

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

Utiliza el vectorizado versión del operador ∈, verificando la contención en la cadena de todos los caracteres en el rango de a a z Luego suma el BitArray resultante y lo divide por el número total de letras posibles.

Pruébalo en línea!

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

Pruébalo en línea!

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

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

Pruébalo en línea!

Stax , 9 bytes

░║üy$}╙+C

Ejecutar y depurarlo

Jalea , 8 bytes

ŒuØAe€Æm

Pruébalo en línea!

Explicación

Œ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

Pruébalo en línea!

JavaScript (Node.js) , 47 bytes

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

Pruébalo en línea!

Python 3 , 51 49 bytes

51 -> 49 bytes, gracias a alexz02

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

Pruébalo en línea!

Japt , 9 bytes

;CoU Ê/26

Intentalo

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

Pruébalo en línea!

Un poco más largo que la respuesta de Python 3 de ArBo, pero publicado como un enfoque diferente en Python 2 de todos modos.

rubí -n , 38 34 bytes

-4 bytes de @historcrat!

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

Pruébalo en línea!

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: redondea hacia abajo)

Versión alternativa de 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.;}

Esto toma prestado algo de la respuesta de @Steadybox.