编写一个函数或程序，该函数或程序将一个字符串作为输入，如果该字符串是一个连字符（一个字母序列，包含英文字母中的每个字母中的至少一个字母），则输出一个真值，否则输出一个假值。

大小写字母应忽略不计；如果字符串是abcdefghijklmnopqrstuvwXYZ，则该函数仍应返回真实值。请注意，字符串中可以包含其他任何字符，因此123abcdefghijklm NOPQRSTUVWXYZ321将返回真实值。空输入应返回假值。

测试用例

AbCdEfGhIjKlMnOpQrStUvWxYz

==> True


ACEGIKMOQSUWY
BDFHJLNPRTVXZ

==> True


public static void main(String[] args)

==> False


The quick brown fox jumped over the lazy dogs. BOING BOING BOING

==> True

这是代码高尔夫。适用标准规则。以字节为单位的最短代码获胜。

Pyth，7个字节

L!-Grb0

说明：

L             lambda (implicit b:)
    rb0       Convert b to lowercase
   G          Lowercase alphabet, "abcd...z"
  -           Set difference, all elts of first that aren't in second
 !            Logical NOT (The empty string is falsey)

在此处尝试完整程序的单行版本。

Perl 6，20个字节

'a'..'z'⊆*.lc.comb

用法：

my &code = 'a'..'z'⊆*.lc.comb;
#  the parameter is ^ there

say code '123abcdefghijklm NOPQRSTUVWXYZ321' # True
say code '123abcdefghijklm NOPQRSTUVWXY'     # False

我使用的⊆是U+2286 SUBSET OF OR EQUAL TO运算符的3个字节的“法语”版本（），而不是4个字节的“德克萨斯州”运算符（(<=)），它前面也需要一个额外的空间。

GS2，11 9个字节

☺ 6ΘàB1."

感谢@MitchSchwartz打高尔夫球2个字节！

源代码使用CP437编码。在线尝试！

这个怎么运作

☺              Push 32 (code point of space).
  6            Bitwise OR.
   Θ           Make a block of these two instructions and map it over the input.
               This turns uppercase letters into their lowercase counterparts.
      à        Push the lowercase alphabet.
       B1      Swap and apply set difference.
         ."    Push the logical NOT of the length of the result.

JavaScript ES6、51 57

编辑 6个字节保存thx @ user81655

a=>new Set(a.toUpperCase().match(/[A-Z]/g)).size>25

测试片段

F=a=>new Set(a.toUpperCase().match(/[A-Z]/g)).size>25

function update() {  O.innerHTML=F(I.value) }
I.value='qwertyuiopasdfghjklzxcvbnm';update()

input { width: 70% }

<input id=I oninput='update()'>
<pre id=O></pre>

[R 50，46 39个字节

all(sapply(letters,grepl,readline(),T))

编辑可tolower通过添加ignore.case=TRUE（T）来减少需求

O，11个字节

GQ_s{n-}dS=

在线尝试。

可悲的是，O没有设定差：/

说明

G            Pushes the alphabet to the stack
 Q           Pushes input to the stack
  _          Converts the string to lowercase
   s         Split string into char array
    {  }d    Iterate through array
     n       Pushes current element to the stack
      -      String subtraction
         S   Pushes a blank string to the stack
          =  Equals

朱莉娅38字节

s->endof(∩('a':'z',lowercase(s)))>25

这很简单- lowercase处理大写/小写字母问题，'a':'z'保留所有小写字母，∩是交集，删除不是字母的任何字符，并且因为'a':'z'出现在首位，每个字母中只有一个s。endof是获得结果数组长度的最短方法，如果它是26，则它是一个pangram（不能超过26，并且>25相对于保存一个字节==26）。

Python 2，53 51字节

f=lambda s,c=65:c>90or(chr(c)in s.upper())*f(s,c+1)

替代解决方案：

lambda s:all(chr(c)in s.upper()for c in range(65,91))

lambda s:not set(range(65,91))-set(map(ord,s.upper()))

感谢xnor指出集合中有一个<=运算符，用于备用51：

lambda s:set(range(65,91))<=set(map(ord,s.upper()))

视网膜，22字节

Msi`([a-z])(?!.*\1)
26

在线尝试。

第一行与字符串中以后不再出现的任何字母匹配。这样可以确保我们每个字母最多匹配一次，无论它出现的频率如何。匹配模式默认情况下会将字符串替换为找到的匹配数。因此，在第二阶段，我们26将根据第一个输入的结果进行匹配，这将给出0或1，具体取决于我们是否找到了最多26个匹配项。

Minkolang 0.14，18字节

$o7$ZsrlZ'26'$ZN.

在这里尝试。

说明

$o                    Read in whole input as characters
  7$Z                 Uppercase every letter
     s                Sort
      r               Reverse
       lZ             Alphabet - uppercase and lowercase
         '26'         Pushes 26 on the stack
             0$Z      Count how often the top 26 numbers of the stack appear in the stack
                N.    Output as number and stop.

Python 3.5，47个字节

lambda s:{*map(chr,range(65,91))}<={*s.upper()}

与Mitch Schwartz的回答相同的原理，但使用PEP 0448的*解压缩增强功能，最早是在Python 3.5中引入的。

这个版本与我在Mitch的评论中所写的内容略有不同，因为我将数字转换为字母，反之亦然。那是因为，这就是我写出最初尝试解决方案的方式，然后才发现我不能不完全复制他的方法而超越Mitch。因此，请考虑调整我剩余的独创性！

红宝石，41 33

->s{(?a..?z).all?{|c|s[/#{c}/i]}}

用法

p=->s{(?a..?z).all?{|c|s[/#{c}/i]}}
p["AbCdEfGhIjKlMnOpQrStUvWxYz"] 
  #=> true
p["ACEGIKMOQSUWY
BDFHJLNPRTVXZ"]
  #=> true
p["public static void main(String[] args)"]
  #=> false
p["The quick brown fox jumped over the lazy dogs. BOING BOING BOING"]
  #=> true

感谢Vasu Adari为我节省了8个字节

R，53 45字节

all(97:122%in%utf8ToInt(tolower(readline())))

53字节的旧版本：

all(letters%in%strsplit(tolower(readline()),"")[[1]])

用法：

> all(97:122%in%utf8ToInt(tolower(readline())))
The quick brown fox jumps over the lazy dog
[1] TRUE
> all(97:122%in%utf8ToInt(tolower(readline())))
Write a function or program that takes as its input a string and prints a truthy value if the string is a pangram and a falsey value otherwise.
[1] FALSE
> all(97:122%in%utf8ToInt(tolower(readline())))
123abcdefghijklm NOPQRSTUVWXYZ321
[1] TRUE
> all(97:122%in%utf8ToInt(tolower(readline())))
Portez ce vieux whisky au juge blond qui fume
[1] TRUE

MATLAB / 八度，35 33字节

@(x)~nnz(setdiff(65:90,upper(x)))

在线尝试！

如果输入x是Pangram，则匿名函数返回逻辑1；否则输入逻辑0。

本质上，它使用与@ThomasKwa的Pyth解决方案相同的方法。大写字母范围（65:91）中的所有字符和输入字符串（转换为大写字母）之间的设置差异。字母中但输入字符串中没有的任何字符均由返回setdiff。仅当由集合差返回的数组为空时，字符串才为pangram。

与之相比，使用大写而不是小写可以节省几个字节，'a':'z'因为可以代替使用ASCII值来确定范围。

Haskell，59 56 53 51字节

p s=and[any(`elem`map toEnum[a,a+32])s|a<-[65..90]]

在线尝试！

说明：

给出一个输入字符串s，对于每个a在范围65〜90（对于ASCII码A到Z）则检查在任何字符是否s是等于或者a（上壳体字符）或a+32（下壳体字符），转换为一个字符toEnum。这将生成一个布尔值列表。and检查它们是否全部True。

旧版本：

import Data.Char
p s=and[any((==)a.toUpper)s|a<-['A'..'Z']]

对于每个大写字母，请检查大写字母是否s等于它。any(==a)s与相同，elem a s但允许s在比较之前修改的元素-在这种情况下，将它们隐蔽为大写。

Japt，14个字节

#ao#{ e@Uv fXd

在线尝试！

这个怎么运作

        // Implicit: U = input string
#ao#{   // Generate a range of integers from charCode("a") to charCode("{").
e@      // Check if every item X in this range returns truthily to:
Uv fXd  //  convert U to lowercase, and put all instances of X.toCharCode() in an array.
        // This returns false if U does not contain one of the characters.
        // Implicit: output last expression

CJam，11个字节

'[,65>qeu-!

这是一个完整的程序。在线尝试。

说明：

'[,65>  Build upper case alphabet (see CJam tips thread).
q       Get input.
eu      Convert to all upper case.
-       Set difference between alphabet and upper cased input.
!       Negate.

Javascript，110 109 99 95 93字节

a=prompt(b=0).toUpperCase();for(i=65;i++<91;)b+=!~a.indexOf(String.fromCharCode(i));alert(!b)

感谢Thomas Kwa，节省了6个字节，部分感谢ev3，节省了10个字节。

05AB1E，4个字节（可能是非竞争）

lêAå

在线尝试！

l    # Push lowercase input.
 ê   # Push sorted, uniquified lowercase input.
  A  # Push lowercase alphabet.
   å # Is lowercase alphabet in sorted, uniquified, lowercase input?
     # True if panagram, false if not.

2sable，6 5字节

6字节版本：

AIl-g_

在线尝试！

说明：

A        Push alphabet
 Il      Push lowercase input
   -     Remove all chars of input from alphabet
    g    Get length of the remainder
     _   Print negative bool, where length < 1 = 1 (true), length > 0 = 0 (false)

5字节版本，灵感来自carusocomputing的05AB1E答案：

lÙ{Aå

在线尝试！

说明：

l        Push lowercase input
 Ù{      Push sorted uniquified input
   A     Push alphabet
    å    Is alphabet in sorted, uniquified input?

Brachylog，4个字节

ḷo⊇Ạ

在线尝试！

        The input
ḷ       lowercased
 o      sorted
  ⊇     is a superlist of
   Ạ    the lowercase alphabet.

TeaScript，12个字节

Sz.e»xL.I(l©

自从我杀死了 TeaScript之后，第一篇TeaScript帖子：p

在线尝试

不打高尔夫球

Sz.e(#xL.I(l))

Sz   // Lower case alphabet
.e(#   // Loop through alphabet, ensure
       // for every character, below returns true
    xL    // Input lowercased
    .I(l) // Checks if above contains current char
)

的JavaScript ES6，124个 114 113字节

我相信这可以打更多。

v=(Q,s=[...Array(26)].map((x,i)=>String.fromCharCode(i+97)))=>s.length-1?Q.search(RegExp(s.pop(),"i"))+1&&v(Q,s):1

生成一个匿名函数。

v=(Q,s=[...Array(26)].map((x,i)=>String.fromCharCode(i+97)))=>s.length-1?Q.search(RegExp(s.pop(),"i"))+1&&v(Q,s):1

alert(v(prompt("Enter pangram:")));

C，107字节

#include<string.h>
int p(char*i){int a=64;while(++a<91)if(!strchr(i,a)&!strchr(i,a+32))return 0;return 1;}

ES6，68个字节

s=>[..."abcdefghijklmnopqrstuvwxyz"].every(x=>RegExp(x,"i").test(s))

该字符串看起来非常浪费，但我不知道有什么更好的方法。

Scala，59 48 46字节

print(('a'to'z'diff(readLine.map(_|32)))==Nil)

Bash，45 42字节

41字节程序，加上1，因为必须使用调用它bash -e：

for i in {a..z}
{ [ ${1//[^$i${i^}]} ]
}

令人惊讶的是，我设法在Bash答案中没有引号字符！（是的，我检查了以等开头的输入-f）。

这假设一个语言环境，其中小写英文字母从a到连续z。输入是通过程序的第一个参数。

这种工作方式是，对于每个字母$i，我们通过删除所有其他字符来测试字符串是否包含字符串$i或等同${i^}于大写字母。如果结果为空字符串，则输入不包含该字母，我们以1（false）退出。如果我们得到一个非空的结果，那么我们通过了测试，然后转到下一个字母。如果输入字符串包含每个英文字母，我们将到达程序的结尾，因此以0（true）退出。

Perl 5，33个字节

$i=<>;map$=*=$i=~/$_/i,a..z;say$=

PlatyPar，14个字节

'a'z_,X,F(x;l!

说明（即将推出堆栈可视化器功能！）：

               ## Implicit: push the input (as a string) to the stack
'a'z_          ## Push the range of a-z (the alphabet) to the stack
     ,X        ## Invert stack, expand input string into individual characters
       ,       ## Invert again
        F  ;   ## Fold (While stack.length > 1)
         (      ## Rotate left, moving the first letter of the input string to the top
          x     ## remove any occurences of that letter from the alphabet array
            l! ## Negate the length of the array, so if there's nothing left
               ## output true, else output false

如果我有一个荒唐的“按字母顺序排列所有字母”功能，那将是10 ...

在线尝试！

Pyke，6个字节

l1GR-!

在这里尝试！

l1     -   input().lower()
  G -  -  set_difference(alphabet,^)
     ! - not ^