介绍

给定的字符串使用多少英文字母？前一句使用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

在线尝试！

长度相同，与上一个长度基本相同，但是没有“内置”字符串方法。

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。

在线尝试或验证更多测试用例。

@Grimy提供的6字节替代：

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＃交互式编译器），56 49字节

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

在线尝试！

-6字节归功于innat3

APL（Dyalog扩展），10 字节^SBCS

匿名默认前缀功能。返回小数部分。

26÷⍨∘≢⎕A∩⌈

在线尝试！

⌈ 大写

⎕A∩ 与大写字母相交 A相交

≢ 提示长度

∘ 然后

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

在线尝试！

说明：

将输入转换为小写，以97为模（ASCII中的“ az”为97-122，以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个字节

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

在线尝试！

转换为大写字母，然后转换为ASCII码点，并检查与A：Z对应的值65:90。

视网膜0.8.2，45字节

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

在线尝试！链接包括测试用例。说明：

T`Llp`ll_

小写字母并删除标点符号。

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

重复数据删除。

.
100$*

乘以100。

^
13$*

加13。

.{26}

整数除以26，然后转换为十进制。

APL（Dyalog扩展），8字节

⌹∘≤⍨⎕A∊⌈

在线尝试！

基于Adám的回答

⌈ 大写

⎕A∊长度为26的布尔（0或1）向量，指示字符串中的英语A lphabet 字母是什么

⌹∘≤⍨ 算术平均值，即参数的矩阵除法和相同长度的全1向量

木炭，11字节

Ｉ∕ＬΦβ№↧θι²⁶

在线尝试！链接是详细版本的代码。输出为小数（或1为小写）。说明：

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

批次，197个字节

@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

在STDIN上输入并输出舍入百分比。说明：

@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

从字符串中依次删除每个字母。由于Batch解析变量的方式，调用子例程以检查是否有任何更改。

@cmd/cset/an/26

计算结果的百分比。

@exit/b
:c

子程序的开始。

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

如果删除字母更改了字符串，则增加字母计数。

佩佩，155个 138字节

rEeEeeeeeEREeEeEEeEeREERrEEEEErEEEeReeReRrEeeEeeeeerEEEEREEeRERrErEErerREEEEEeREEeeRrEreerererEEEEeeerERrEeeeREEEERREeeeEEeEerRrEEEEeereEE

在线尝试！输出为十进制形式。

说明：

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个字节

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

在线尝试！

J，30个字节

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

在线尝试！

视网膜，57 46 35字节

.
$L
[^a-z]

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

-11字节的灵感来自@Neil在除法前添加一元数13的技巧。
另外-11个字节，直接感谢@Neil。
四舍五入为一个整数。

在线尝试。

57 46 40字节版本，可用于十进制输出：

.
$L
[^a-z]

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

相同的-11个字节，以及额外的-6个字节，这要归功于 @Neil，。

输出在逗号后加一个截短的^†小数点（^†即$0.1538$ （$\frac{4}{26}$）15.3代替15.4）输出。这是通过计算$\lfloor{\frac{1000 × \text{unique_letters}}{26}\rfloor}$ 然后手动插入小数点。

在线尝试。

说明：

将所有字母转换为小写：

.
$L

删除所有非字母：

[^a-z]

统一所有字母：

D`.

将每个唯一字母替换为1000个下划线：

.
1000*

计算26个相邻下划线在其中的匹配次数：

C`_{26}

在正确的位置插入一个点：

-1`\B
.

Java 8，62 59字节

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

-3个字节，感谢@OlivierGrégoire。

在线尝试。

说明：

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

朱莉娅1.0，34字节

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

使用∈运算符的向量化版本，检查字符串中是否包含从a到z的所有字符。然后将结果BitArray相加，然后除以可能的字母总数。

在线尝试！

C，96字节

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

在线尝试！

Perl 5，24 -MList::Util=uniq -p个字节

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

在线尝试！

Stax，9 个字节

░║ü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.