บทนำ

สายอักขระที่กำหนดให้ใช้มีตัวอักษรภาษาอังกฤษเท่าใด ประโยคก่อนหน้าใช้ 77% มีตัวอักษรที่ไม่ซ้ำกัน 20 ตัว (howmucftenglisapbdvr) และ 20/26 ≃ 0.77

ท้าทาย

สำหรับสตริงอินพุตให้ส่งคืนเปอร์เซ็นต์ของตัวอักษรของตัวอักษรภาษาอังกฤษที่มีอยู่ในสตริง

• คำตอบอาจเป็นเปอร์เซ็นต์หรือในรูปแบบทศนิยม

• สตริงอินพุตสามารถมีตัวพิมพ์ใหญ่และตัวพิมพ์เล็กเช่นเดียวกับเครื่องหมายวรรคตอน อย่างไรก็ตามคุณสามารถสันนิษฐานได้ว่าพวกเขาไม่มีเครื่องหมายกำกับเสียงหรืออักขระเน้นเสียง

กรณีทดสอบ

อินพุต

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

เอาต์พุตที่ถูกต้องบางอย่าง

77%, 76.9, 0.7692

การป้อนข้อมูล:

The quick brown fox jumps over the lazy dog

ผลลัพธ์ที่ถูกต้องทั้งหมด:

100%, 100, 1

ผลลัพธ์ที่คาดหวังสำหรับ"@#$%^&*?!"และ""เป็น 0

Python 3 , 42 ไบต์

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

ลองออนไลน์!

เรากรองอักขระที่ไม่ใช่ตัวอักษรทั้งหมดออกจากสตริงโดยนำความแตกต่าง (การตั้งค่า) ของการแสดงตัวพิมพ์ใหญ่และตัวพิมพ์เล็ก จากนั้นเราใช้ความยาวและหารด้วย 26

Python 3 , 46 ไบต์

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

ลองออนไลน์!

นับตัวอักษรที่เป็นตัวอักษร (ตัวพิมพ์เล็ก) ที่ไม่ซ้ำกันและหารด้วย 26 ใน Python 2 จะต้องใช้อักขระเพิ่มอีก 3 ตัว สองสำหรับการเปลี่ยน{*...}เป็นset(...)และหนึ่งสำหรับการทำ 26 ลอย: 26.เพื่อหลีกเลี่ยงการแบ่งพื้น

Python 3 , 46 ไบต์

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

ลองออนไลน์!

ความยาวเท่ากันโดยพื้นฐานเหมือนกับความยาวก่อนหน้านี้ แต่ไม่มีเมธอดสตริง "built-in"

MATL , 8 ไบต์

2Y2jkmYm

ลองที่ MATL Online

คำอธิบาย

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

ระดับแปดเสียง / MATLAB, 33 ไบต์

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

ลองออนไลน์!

คำอธิบาย

@(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 ไบต์

lASåÅA

-1 ขอบคุณไบต์@LuisMendo

ลองออนไลน์หรือตรวจสอบกรณีทดสอบอีกสองสามข้อ

ทางเลือก 6 ไบต์โดย@Grimy :

láÙg₂/

ลองออนไลน์หรือตรวจสอบกรณีทดสอบอีกสองสามข้อ

โปรแกรมทั้งสองแสดงผลลัพธ์เป็นทศนิยม

คำอธิบาย:

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 ไบต์

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

ลองออนไลน์!

-6 ไบต์ขอบคุณinnat3

APL (Dyalog Extended) , 10 ไบต์^SBCS

ฟังก์ชันนำหน้าเงียบโดยไม่ระบุชื่อ ส่งคืนเศษส่วนทศนิยม

26÷⍨∘≢⎕A∩⌈

ลองออนไลน์!

⌈ ตัวพิมพ์ใหญ่

⎕A∩ แยกกับตัวพิมพ์ใหญ่A lphabet

≢ ความยาวนับ

∘ แล้วก็

26÷⍨ หารด้วยยี่สิบหก

Perl 6 , 27 24 ไบต์

-3 ไบต์ขอบคุณ nwellnhof

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

ลองออนไลน์!

Bash และ Gnu utils ( 81 78 68 60 42 ไบต์)

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

-8 ไบต์ขอบคุณ @wastl

-18 ไบต์ขอบคุณNahuelโดยใช้ลูกเล่นบางอย่างที่ฉันไม่รู้:

• sort -f และ grep -iไม่สนใจขนาดตัวพิมพ์
• sort -u เป็นการทดแทน | uniq

K (oK) , 19 15 ไบต์

วิธีการแก้:

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

ลองออนไลน์!

คำอธิบาย:

แปลงอินพุตเป็นตัวพิมพ์เล็ก modulo 97 ("az" คือ 97-122 ใน ASCII, modulo 97 ให้ 0-25) ใช้ผลสรุปที่ไม่ซ้ำกันที่ต่ำกว่า 26 และแปลงเป็นเปอร์เซ็นต์ของ 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 ...

หมายเหตุ:

• -1 ไบต์ขอบคุณ ngn, 1-%[;26]=>1-1%26%
• -3 ไบต์แรงบันดาลใจจาก ngn #(!26)^=>+/26>?

PowerShell , 55 52 ไบต์

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

ลองออนไลน์!

ความพยายามครั้งแรกยังคงพยายามคิดแบบสุ่ม

แก้ไข: @Veskah ชี้ให้เห็นว่า ToUpper บันทึกเป็นไบต์เนื่องจากช่วงของตัวเลขยังลบส่วนเกินออกไป ()และช่องว่างออก

การขยายตัว:
($args|% ToUpper|% ToCharArray|sort|get-unique|where{$_-in 65..90}).count/26

เปลี่ยนสตริงเป็นตัวพิมพ์ใหญ่ที่ต่ำกว่าทั้งหมดขยายเป็นอาร์เรย์เรียงลำดับองค์ประกอบและเลือกตัวอักษรที่ไม่ซ้ำกัน (gu ต้องการอินพุตที่เรียงลำดับ) เก็บเฉพาะอักขระที่มีค่า ASCII 97 ถึง 122 (a ถึง z) 65 ถึง 90 (A ถึง Z) นับผลรวมและหารด้วย 26 สำหรับเอาต์พุตทศนิยม

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!

loosely based on Adám's answer

⌈ uppercase

⎕A∊ boolean (0 or 1) vector of length 26 indicating which letters of the English Alphabet are in the string

⌹∘≤⍨ arithmetic mean, i.e. matrix division of the argument and an all-1 vector of the same length

Charcoal, 11 bytes

Ｉ∕ＬΦβ№↧θι²⁶

Try it online! Link is to verbose version of code. Output is as a decimal (or 1 for pangrams). Explanation:

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

Batch, 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

Takes input on STDIN and outputs a rounded percentage. Explanation:

@set/ps=

Input the string.

@set s=%s:"=%

Strip quotes, because they're a headache to deal with in Batch.

@set n=13

Start with half a letter for rounding purposes.

@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

Delete each letter in turn from the string. Invoke the subroutine to check whether anything changed, because of the way Batch parses variables.

@cmd/cset/an/26

Calculate the result as a percentage.

@exit/b
:c

Start of subroutine.

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

If deleting a letter changed the string then increment the letter count.

Pepe, 155 138 bytes

rEeEeeeeeEREeEeEEeEeREERrEEEEErEEEeReeReRrEeeEeeeeerEEEEREEeRERrErEErerREEEEEeREEeeRrEreerererEEEEeeerERrEeeeREEEERREeeeEEeEerRrEEEEeereEE

Try it online! Output is in decimal form.

Explanation:

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

Try it online!

J, 30 bytes

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

Try it online!

Retina, 57 46 35 bytes

.
$L
[^a-z]

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

-11 bytes taking inspiration from @Neil's trick of adding unary 13 before dividing.
Another -11 bytes thanks to @Neil directly.
Rounds (correctly) to a whole integer.

Try it online.

57 46 40 bytes version which works with decimal output:

.
$L
[^a-z]

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

Same -11 bytes as well as an additional -6 bytes thanks to @Neil.

Outputs with one truncated^† decimal after the comma (^† i.e. $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.