Escreva uma função ou programa que tenha como entrada uma sequência e imprima um valor verdadeiro se a sequência for um pangram (uma sequência de letras contendo pelo menos uma de cada letra no alfabeto inglês) e um valor falsey caso contrário.

Letras maiúsculas devem ser ignoradas; Se a sequência for abcdefghijklmnopqrstuvwXYZ, a função ainda deve retornar um valor verdadeiro. Observe que a string pode conter outros caracteres, portanto 123abcdefghijklm NOPQRSTUVWXYZ321, retornaria um valor verdadeiro. Uma entrada vazia deve retornar um valor falsey.

Casos de teste

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

Isso é código de golfe. Aplicam-se regras padrão. O menor código em bytes vence.

Pitão, 7 bytes

L!-Grb0

Explicação:

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)

Experimente a versão completa do programa, aqui .

Perl 6 , 20 bytes

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

uso:

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

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

Eu usei a versão "francesa" (3 ⊆) do U+2286 SUBSET OF OR EQUAL TOoperador ( ) em vez da versão "texas" (4) da bytes ( (<=)), que também exigiria um espaço extra à sua frente.

GS2, 11 9 bytes

☺ 6ΘàB1."

Obrigado a @MitchSchwartz por jogar fora 2 bytes!

O código fonte usa a codificação CP437. Experimente online!

Como funciona

☺              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

Editar 6 bytes, salvar thx @ user81655

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

Snippet de teste

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 bytes

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

Editar elimina a necessidade toloweradicionando ignore.case=TRUE( T)

O, 11 bytes

GQ_s{n-}dS=

Experimente online.

Infelizmente, O não definiu a diferença: /

Explicaçã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

Julia, 38 bytes

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

Isso é simples - lowercaselida com a questão de letras maiúsculas / minúsculas, 'a':'z'mantém todas as letras minúsculas, ∩é interseção, remove qualquer caractere que não seja uma letra e, como 'a':'z'vem primeiro, terá apenas uma de cada letra que aparece s. endofé a maneira mais curta de obter o comprimento da matriz resultante e, se for 26, é um pangram (não pode ser superior a 26 e >25salva um byte em relação a ==26).

Python 2, 53 51 bytes

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

Soluções alternativas:

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()))

Agradecemos ao xnor por apontar que os conjuntos têm um <=operador, por um 51 alternativo:

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

Retina , 22 bytes

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

Experimente online.

A primeira linha corresponde a qualquer letra que não apareça mais tarde na sequência. Isso garante que não correspondamos a cada letra no máximo uma vez, não importa com que frequência ela ocorra. Por padrão, o modo de correspondência substitui a sequência pelo número de correspondências encontradas. Portanto, no segundo estágio, comparamos 26com o resultado da primeira entrada, que fornecerá um 0ou outro 1, dependendo se encontramos o máximo de 26 correspondências ou não.

Minkolang 0.14 , 18 bytes

$o7$ZsrlZ'26'$ZN.

Experimente aqui.

Explicação

$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 bytes

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

Mesmo princípio que a resposta de Mitch Schwartz , mas usando as melhorias do PEP 0448 para *descompactar, introduzido pela primeira vez no Python 3.5.

Esta versão difere um pouco do que escrevi no meu comentário no post de Mitch, na medida em que transformo os números em letras em vez de vice-versa. Foi por isso que escrevi minhas tentativas originais de solução, antes de descobrir que não conseguia vencer Mitch sem copiar completamente sua abordagem. Portanto, considere que ajustar meu único pedaço de originalidade restante!

Ruby, 41 33

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

Uso

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

Obrigado a Vasu Adari por me salvar 8 bytes

R, 53 45 bytes

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

Versão antiga em 53 bytes:

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

Uso:

> 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 / Oitava , 35 33 bytes

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

Experimente online!

A função anônima retorna um lógico 1 se a entrada xfor um pangram ou um lógico 0 se não for.

Essencialmente, ele usa a mesma abordagem que a solução Pyth da @ ThomasKwa. A diferença definida entre todos os caracteres no intervalo de letras maiúsculas ( 65:91) e a sequência de entrada (convertida em maiúsculas). Quaisquer caracteres que estão no alfabeto, mas não na sequência de entrada, são retornados por setdiff. Somente se a matriz retornada pela diferença definida estiver vazia a sequência será um pangram.

Usar maiúsculas em vez de minúsculas economiza alguns bytes em comparação com 'a':'z'porque o valor ASCII pode ser usado para fazer o intervalo.

Haskell , 59 56 53 51 bytes

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

Experimente online!

Explicação:

Forneça uma sequência de entrada s, para cada um dos aintervalos de 65 a 90 (os códigos ASCII para Ato Z) é verificado se algum caractere sé igual a a(o caractere em maiúsculas) ou a+32(o caractere em minúsculas), convertido em um caractere por toEnum. Isso gera uma lista de booleanos. andverifica se são todos True.

Versão antiga:

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

Para cada letra maiúscula do alfabeto, verifique se alguma letra smaiúscula é igual a ela. any(==a)sé o mesmo que elem a spermite modificar os elementos santeriores à comparação - nesse caso, oculte-os em maiúsculas.

Japonês , 14 bytes

#ao#{ e@Uv fXd

Experimente online!

Como funciona

        // 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 bytes

'[,65>qeu-!

Este é um programa completo. Experimente online .

Explicação:

'[,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 bytes

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

Economizou 6 bytes graças a Thomas Kwa e 10 graças em parte ao ev3.

05AB1E , 4 bytes (provavelmente não concorrente)

lêAå

Experimente online!

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 bytes

Versão de 6 bytes:

AIl-g_

Experimente online!

Explicação:

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)

Versão de 5 bytes, inspirada na resposta 05AB1E da carusocomputing :

lÙ{Aå

Experimente online!

Explicação:

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

Braquilog , 4 bytes

ḷo⊇Ạ

Experimente online!

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

TeaScript , 12 bytes

Sz.e»xL.I(l©

Primeira postagem do TeaScript desde que eu matei o TeaScript: p

Experimente online

Ungolfed

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 bytes

Tenho certeza que isso pode ser jogado mais.

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

Gera uma função anônima.

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 bytes

#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 bytes

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

Essa corda parece terrivelmente inútil, mas não conheço nenhuma maneira melhor.

Scala, 59 48 46 bytes

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

Bash, 45 42 bytes

Programa de 41 bytes, mais 1 porque deve ser chamado com bash -e:

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

Surpreendentemente, consegui uma resposta do Bash sem caracteres de aspas! (sim, eu verifiquei com entradas começando com -fe afins).

Isso pressupõe uma localidade em que as letras em minúsculas em inglês são contíguas de apara z. A entrada é feita através do primeiro argumento do programa.

Assim, para cada letra alfabética $i, testamos se a string contém $iou seu equivalente em maiúscula ${i^}removendo todos os outros caracteres. Se isso resultar na cadeia vazia, a entrada não continha essa letra e sairemos com 1(false). Se tivermos um resultado não vazio, passamos no teste e passamos para a próxima letra. Se a string de entrada contiver todas as letras em inglês, chegaremos ao final do programa, saindo com 0(true).

Perl 5, 33 bytes

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

PlatyPar , 14 bytes

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

Explicação (recurso do visualizador de pilhas em breve!):

               ## 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

Se eu tivesse uma ridícula função "empurrar todas as letras do alfabeto", isso seria 10 ...

Experimente online !

Pyke, 6 bytes

l1GR-!

Experimente aqui!

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