Escriba una función o programa que tome como entrada una cadena e imprima un valor verdadero si la cadena es un pangrama (una secuencia de letras que contiene al menos una de cada letra en el alfabeto inglés) y un valor falsey de lo contrario.

El caso de las letras debe ser ignorado; Si la cadena es abcdefghijklmnopqrstuvwXYZ, entonces la función aún debería devolver un valor verdadero. Tenga en cuenta que la cadena puede contener cualquier otro carácter, por 123abcdefghijklm NOPQRSTUVWXYZ321lo que devolvería un valor verdadero. Una entrada vacía debería devolver un valor falsey.

Casos de prueba

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

Este es el código de golf. Aplican reglas estándar. El código más corto en bytes gana.

Pyth, 7 bytes

L!-Grb0

Explicación:

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)

Pruebe la versión de línea completa del programa completo aquí .

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

Utilicé la versión "francesa" de 3 bytes ( ⊆) del U+2286 SUBSET OF OR EQUAL TOoperador en lugar de la versión "texas" de 4 bytes ( (<=)), que también habría requerido un espacio adicional delante.

GS2, 11 9 bytes

☺ 6ΘàB1."

¡Gracias a @MitchSchwartz por jugar 2 bytes!

El código fuente usa la codificación CP437. Pruébalo en línea!

Cómo 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 guardar thx @ user81655

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

Fragmento de prueba

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 la necesidad de toloweragregar ignore.case=TRUE( T)

O, 11 bytes

GQ_s{n-}dS=

Pruébalo en línea.

Lamentablemente, O no tiene una diferencia establecida: /

Explicación

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

Esto es simple: lowercasetrata el problema de mayúsculas / minúsculas, 'a':'z'contiene todas las letras minúsculas, ∩es la intersección, elimina cualquier carácter que no sea una letra y, como 'a':'z'viene primero, solo tendrá una de cada letra que aparezca s. endofes la forma más corta de obtener la longitud de la matriz resultante, y si es 26, entonces es un pangrama (no puede ser más de 26, y >25guarda un byte relativo a ==26).

Python 2, 53 51 bytes

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

Soluciones alternas:

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

Gracias a xnor por señalar que los conjuntos tienen un <=operador, por un 51 alternativo:

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

Retina , 22 bytes

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

Pruébalo en línea.

La primera línea coincide con cualquier letra que no aparece más tarde en la cadena. Eso asegura que no coincidamos con cada letra como máximo una vez, sin importar con qué frecuencia ocurra. El modo de coincidencia reemplazará por defecto la cadena con el número de coincidencias encontradas. Por lo tanto, en la segunda etapa, hacemos coincidir 26el resultado de la primera entrada, que dará uno 0o más 1, dependiendo de si encontramos el máximo de 26 coincidencias o no.

Minkolang 0.14 , 18 bytes

$o7$ZsrlZ'26'$ZN.

Pruébalo aquí

Explicación

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

El mismo principio que la respuesta de Mitch Schwartz , pero usando las mejoras PEP 0448 para *desempacar, primero introducido en Python 3.5.

Esta versión difiere ligeramente de lo que escribí en mi comentario a la publicación de Mitch, en que convierto los números en letras en lugar de viceversa. Eso es porque así es como escribí mis intentos originales de una solución, antes de descubrir que no podía superar a Mitch sin copiar directamente su enfoque. ¡Así que considera ese ajuste mi único fragmento de originalidad!

Rubí, 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

Gracias a Vasu Adari por salvarme 8 bytes.

R, 53 45 bytes

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

Versión anterior a 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 / Octave , 35 33 bytes

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

Pruébalo en línea!

La función anónima devuelve un 1 lógico si la entrada xes un pangrama, o un 0 lógico si no lo es.

Esencialmente utiliza el mismo enfoque que la solución Pyth de @ ThomasKwa. La diferencia establecida entre todos los caracteres en el rango del alfabeto en mayúsculas ( 65:91) y la cadena de entrada (convertida a mayúsculas). Todos los caracteres que están en el alfabeto pero no en la cadena de entrada son devueltos por setdiff. Solo si la matriz devuelta por la diferencia establecida está vacía, la cadena es un pangrama.

El uso de mayúsculas en lugar de minúsculas ahorra un par de bytes en comparación con 'a':'z'porque el valor ASCII se puede utilizar en su lugar para hacer el rango.

Haskell , 59 56 53 51 bytes

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

Pruébalo en línea!

Explicación:

Dar una cadena de entrada s, para cada aen el rango de 65 a 90 (los códigos ASCII para Aa Z) se comprueba si cualquier carácter en ses igual a cualquiera de los dos a(el carácter caso superior) o a+32(cuanto menor carácter caso), convertido a un carácter toEnum. Esto genera una lista de booleanos. andcomprueba si son todosTrue .

Versión antigua:

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

Para cada letra del alfabeto en mayúscula, verifique si alguna letra sen mayúscula es igual a ella. any(==a)ses lo mismo elem a spero permite modificar los elementos de santes de la comparación, en este caso, convertirlos a mayúsculas.

Japt , 14 bytes

#ao#{ e@Uv fXd

Pruébalo en línea!

Cómo 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 es un programa completo. Pruébalo en línea .

Explicación:

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

Guardado 6 bytes gracias a Thomas Kwa, y 10 gracias en parte a ev3.

05AB1E , 4 bytes (probablemente no compite)

lêAå

Pruébalo en línea!

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

Versión de 6 bytes:

AIl-g_

Pruébalo en línea!

Explicación:

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)

Versión de 5 bytes, inspirada en la respuesta 05AB1E de carusocomputing :

lÙ{Aå

Pruébalo en línea!

Explicación:

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

Brachylog , 4 bytes

ḷo⊇Ạ

Pruébalo en línea!

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

TeaScript , 12 bytes

Sz.e»xL.I(l©

Primera publicación de TeaScript desde que maté a TeaScript: p

Pruébalo en línea

Sin golf

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

Estoy seguro de que se puede jugar más al golf.

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

Genera una función 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))

Esa cuerda se ve terriblemente derrochadora, pero no conozco una mejor manera.

Scala, 59 48 46 bytes

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

Bash, 45 42 bytes

Programa de 41 bytes, más 1 porque debe invocarse con bash -e:

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

¡Sorprendentemente, logré una respuesta Bash sin comillas! (sí, lo comprobé con entradas que comienzan con-f y similares).

Esto supone una localización donde las letras en inglés en minúsculas son contiguas de aa z. La entrada es a través del primer argumento para el programa.

La forma en que esto funciona es, para cada letra alfabética $i, probamos si la cadena contiene $io su equivalente en mayúsculas ${i^}eliminando todos los demás caracteres. Si esto resulta en una cadena vacía, entonces la entrada no contenía esa letra, y salimos con 1(falso). Si tenemos un resultado no vacío, entonces pasamos la prueba y pasamos a la siguiente letra. Si la cadena de entrada contiene todas las letras en inglés, llegaremos al final del programa, saliendo así con 0(verdadero).

Perl 5, 33 bytes

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

PlatyPar , 14 bytes

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

Explicación (¡la función de visualizador de pila estará disponible próximamente!):

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

Si tuviera una función ridícula de "empujar todas las letras del alfabeto" sería 10 ...

Pruébalo en línea !

Pyke, 6 bytes

l1GR-!

Pruébalo aquí!

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