introduction

Quelle proportion de l'alphabet anglais une chaîne donnée utilise-t-elle? La phrase précédente utilise 77%. Il a 20 lettres uniques (howmucftenglisapbdvr) et 20/26 ≃ 0,77.

Défi

Pour une chaîne d'entrée, renvoyez le pourcentage de lettres de l'alphabet anglais présentes dans la chaîne.

• La réponse peut être en pourcentage ou sous forme décimale.

• La chaîne d'entrée peut avoir des majuscules et des minuscules, ainsi que des signes de ponctuation. Cependant, vous pouvez supposer qu'ils n'ont pas de signes diacritiques ou accentués.

Cas de test

Contribution

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

Quelques sorties valides

77%, 76.9, 0.7692

Contribution:

The quick brown fox jumps over the lazy dog

Toutes les sorties valides:

100%, 100, 1

La sortie attendue pour "@#$%^&*?!"et ""est 0.

Python 3 , 42 octets

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

Essayez-le en ligne!

Nous filtrons tous les caractères non alphabétiques de la chaîne en prenant la différence (définie) des représentations majuscules et minuscules. Ensuite, nous prenons la longueur et divisons par 26.

Python 3 , 46 octets

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

Essayez-le en ligne!

Comptez les caractères alphabétiques uniques (minuscules) et divisez par 26. En Python 2, il faudrait 3 caractères supplémentaires; deux pour changer {*...}en set(...), et un pour faire 26 un flotteur:, 26.pour éviter la division du plancher.

Python 3 , 46 octets

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

Essayez-le en ligne!

Même longueur, essentiellement la même que la précédente, mais sans méthode de chaîne "intégrée".

MATL , 8 octets

2Y2jkmYm

Essayez-le sur MATL Online

Explication

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 octets

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

Essayez-le en ligne!

Explication

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

lASåÅA

-1 octet grâce à @LuisMendo .

Essayez-le en ligne ou vérifiez quelques cas de test supplémentaires .

Alternative de 6 octets fournie par @Grimy :

láÙg₂/

Essayez-le en ligne ou vérifiez quelques cas de test supplémentaires .

Les deux programmes sortent en décimal.

Explication:

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 octets

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

Essayez-le en ligne!

-6 octets grâce à innat3

APL (Dyalog Extended) , 10 octets ^SBCS

Fonction de préfixe tacite anonyme. Renvoie la fraction décimale.

26÷⍨∘≢⎕A∩⌈

Essayez-le en ligne!

⌈ majuscule

⎕A∩ intersection avec l' alphabet majuscule A

≢ longueur du décompte

∘ puis

26÷⍨ diviser par vingt-six

Perl 6 , 27 24 octets

-3 octets grâce à nwellnhof

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

Essayez-le en ligne!

Utilitaires Bash et Gnu ( 81 78 68 60 42 octets)

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

-8 octets grâce à @wastl

-18 octets grâce à Nahuel utilisant des astuces que je ne connaissais pas:

• sort -f et grep -i ignorer la casse
• sort -u est un remplacement pour | uniq

K (oK) , 19 15 octets

Solution:

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

Essayez-le en ligne!

Explication:

Convertissez les entrées en minuscules, modulo 97 ("az" est 97-122 en ASCII, modulo 97 donne 0-25), prenez des résultats uniques, résumez qui sont inférieurs à 26 et convertissez-les en pourcentage 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 ...

Remarques:

• -1 octets grâce à ngn, 1-%[;26]=>1-1%26%
• -3 octets inspirés de ngn #(!26)^=>+/26>?

PowerShell , 55 52 octets

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

Essayez-le en ligne!

Première tentative, toujours essayer des idées aléatoires

EDIT: @Veskah a souligné que ToUpper enregistre un octet en raison de la plage de numéros, également supprimé supplémentaire () et un espace

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

Modifie la chaîne en majuscules inférieures , se développe en un tableau, trie les éléments et sélectionne les lettres uniques (gu a besoin d'une entrée triée), ne conserve que les caractères de valeur ascii 97 à 122 (a à z) 65 à 90 (A à Z), compter le total et diviser par 26 pour la sortie décimale

R , 47 octets

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

Essayez-le en ligne!

Convertit en majuscules puis en points de code ASCII et vérifie les valeurs 65:90 correspondant à A: Z.

Retina 0.8.2 , 45 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

T`Llp`ll_

Lettres minuscules et suppression de la ponctuation.

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

Dédupliquer.

.
100$*

Multipliez par 100.

^
13$*

Ajoutez 13.

.{26}

Entier diviser par 26 et convertir en décimal.

APL (Dyalog Extended) , 8 octets

⌹∘≤⍨⎕A∊⌈

Essayez-le en ligne!

vaguement basé sur la réponse d'Adám

⌈ majuscule

⎕A∊booléen (0 ou 1) vecteur de longueur 26 indiquant quelles lettres de l' alphabet anglais A sont dans la chaîne

⌹∘≤⍨ moyenne arithmétique, c'est-à-dire division matricielle de l'argument et vecteur tout-1 de même longueur

charbon , 11 octets

Ｉ∕ＬΦβ№↧θι²⁶

Essayez-le en ligne! Le lien est vers la version verbeuse du code. La sortie est sous forme décimale (ou 1pour les pangrammes). Explication:

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

Lot, 197 octets

@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

Prend l'entrée sur STDIN et sort un pourcentage arrondi. Explication:

@set/ps=

Saisissez la chaîne.

@set s=%s:"=%

Supprimez les citations, car elles sont un casse-tête à gérer dans Batch.

@set n=13

Commencez par une demi-lettre à des fins d'arrondi.

@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

Supprimez tour à tour chaque lettre de la chaîne. Appelez le sous-programme pour vérifier si quelque chose a changé, en raison de la façon dont Batch analyse les variables.

@cmd/cset/an/26

Calculez le résultat en pourcentage.

@exit/b
:c

Début du sous-programme.

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

Si la suppression d'une lettre modifie la chaîne, incrémentez le nombre de lettres.

Pepe , 155 138 bytes

rEeEeeeeeEREeEeEEeEeREERrEEEEErEEEeReeReRrEeeEeeeeerEEEEREEeRERrErEErerREEEEEeREEeeRrEreerererEEEEeeerERrEeeeREEEERREeeeEEeEerRrEEEEeereEE

Essayez-le en ligne! La sortie est sous forme décimale.

Explication:

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 octets

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

Essayez-le en ligne!

J , 30 octets

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

Essayez-le en ligne!

Rétine , 57 46 35 octets

.
$L
[^a-z]

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

-11 octets s'inspirant de l' astuce de @Neil d'ajouter 13 unaires avant de diviser .
Encore -11 octets grâce à @Neil directement.
Arrondit (correctement) à un entier entier.

Essayez-le en ligne.

57 46 Version 40 octets qui fonctionne avec une sortie décimale:

.
$L
[^a-z]

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

Même -11 octets ainsi que -6 octets supplémentaires grâce à @Neil .

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

Essayez-le en ligne.

Explication:

Convertissez toutes les lettres en minuscules:

.
$L

Supprimer toutes les non-lettres:

[^a-z]

Uniquify toutes les lettres:

D`.

Remplacez chaque lettre unique par 1 000 soulignements:

.
1000*

Comptez le nombre de fois où 26 traits de soulignement adjacents s'y insèrent:

C`_{26}

Insérez un point au bon endroit:

-1`\B
.

Java 8, 62 59 octets

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

-3 octets grâce à @ OlivierGrégoire .

Essayez-le en ligne.

Explication:

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 octets

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

Utilise le vectorisé version de l'opérateur ∈, vérifiant le confinement dans la chaîne pour tous les caractères compris entre a et z. Additionne ensuite le BitArray résultant et divise par le nombre total de lettres possibles.

Essayez-le en ligne!

C, 96 octets

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

Essayez-le en ligne!

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

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

Essayez-le en ligne!

Stax , 9 octets

░║üy$}╙+C

Exécuter et déboguer

Gelée , 8 octets

ŒuØAe€Æm

Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne!

JavaScript (Node.js) , 47 octets

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

Essayez-le en ligne!

Python 3 , 51 49 octets

51 -> 49 octets, grâce à alexz02

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

Essayez-le en ligne!

Japt , 9 octets

;CoU Ê/26

L'essayer

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

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

Essayez-le en ligne!

Un peu plus long que la réponse Python 3 d'ArBo mais affiché comme une approche différente dans Python 2 de toute façon.

Rubis -n , 38 34 octets

-4 octets de @historcrat!

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

Essayez-le en ligne!

C, 95 octets

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

(remarque: arrondi vers le bas)

Version alternative à retour décimal (95 octets):

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

Cela emprunte à la réponse de @Steadybox.