¿Es un pangrama?

42

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.

Arcturus
fuente
3
Puntos más si su código puede verificar si la entrada es un Pungram.
timmyRS
44
Pregunta de solicitud de nombre: ¿Saltó rápidamente el zorro marrón sobre el perro perezoso?

Respuestas:

25

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í .

lirtosiast
fuente
Creo que el camino más corto para solucionar este problema para el salto de línea de la entrada es hacer una función: L!-Grb0. !-Grs.z0También funcionaría pero es más largo.
FryAmTheEggman
Oh, no vi la pregunta actualizada para incluir \ n en la cadena. Gracias.
lirtosiast
6 bytes: pyth.herokuapp.com/…
Maltysen
@Maltysen Si bien existe un consenso (débil) sobre permitir que las cadenas de entrada sean delimitadas por comillas , no estoy seguro de esto, ya que va más allá al requerir la sintaxis de cadena de Python.
lirtosiast
Nunca hubiera pensado que un alfabeto incorporado sería útil ...
Cyoce
16

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.

Brad Gilbert b2gills
fuente
12

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.
Dennis
fuente
El bloqueo rápido m2( \xe9) ahorra 2 bytes.
Mitch Schwartz
@MitchSchwartz Oh, así es como los usas. ¡Gracias!
Dennis
11

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>

edc65
fuente
¿Lo haría a.replace(/[^A-Z]|[^a-z]/g,'')o a.replace(/[^A-Z]/gi,'')trabajaría?
ev3commander
2
@ ev3commander no. Ay adebe convertirse en el mismo personaje, de lo contrario, el conjunto los mantendrá como distintos y el tamaño será> 26
edc65
¿Qué pasa si usa el operador de propagación con [...a.toUpperCase().replace(/[^A-Z]/g,'')].length>25?
Scott
@ScottKaye obviamente no. Pruébalo con 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
edc65
1
@ user81655 correcto, funciona, genial. Gracias. No debería responder comentarios mientras duermo
edc65 12/12/2015
9

R 50 , 46 39 bytes

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

Editar elimina la necesidad de toloweragregar ignore.case=TRUE( T)

mnel
fuente
¿No está muy familiarizado con R, pero no ignore.case=TRUE (T)debería incluirse también en el recuento?
Ruslan
2
@Ruslan lo es! Es Tel final, gracias a la coincidencia de ubicación de argumentos no hay necesidad de especificar realmente el nombre del argumento (y Tes el alias predeterminado para TRUE). El código escrito aquí realiza la acción necesaria tal cual, sin necesidad de agregar nada.
plannapus
9

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
un espagueti
fuente
6

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

Glen O
fuente
6

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()))
Mitch Schwartz
fuente
1
Si no me equivoco, la última expresión es la misma que lambda s:set(range(65,91))<=set(map(ord,s.upper())), también para 51.
xnor
Python 3.5 puede ahorrar bytes aquí: p=lambda s:{*range(65,91)}<={*map(ord,s.upper())}. Por cierto, parece que no puedo encontrar ninguna regla sobre si es lambdanecesario asignar una (como en su primer caso) o no (como en las posteriores). ¿Ayuda?
Tim Pederick
@TimPederick Nombrar el lambda es innecesario a menos que necesite usar la función en otro lugar, como en la primera solución recursiva.
FryAmTheEggman
@TimPederick Gracias por señalarlo. Cambié el nombre de mi respuesta como Python 2 en lugar de solo Python. Tienes la bendición de publicar eso como una nueva respuesta si lo deseas, lo que creo que estaría bien según las normas de la comunidad, aunque no estoy seguro.
Mitch Schwartz
@FryAmTheEggman: Gracias por aclarar. ¡Esa distinción no se me había ocurrido! También he encontrado una meta publicación que explica la regla. Hay dos bytes de algunas cosas que he escrito ...
Tim Pederick
5

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.

Martin Ender
fuente
4

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.
El'endia Starman
fuente
4

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!

Tim Pederick
fuente
4

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.

Alexis Andersen
fuente
2
Puede guardar 8 bytes haciendo que su expresión regular ignore el caso.
Vasu Adari
4

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
plannapus
fuente
4

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.

Tom Carpenter
fuente
¡Gran respuesta! El mío fue 10 bytes más largo
Luis Mendo
4

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.

Laikoni
fuente
3

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
ETHproducciones
fuente
3

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.
Reto Koradi
fuente
3

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.

SuperJedi224
fuente
¿Funcionaría b = 0 para b = []?
ev3commander
No con este enfoque. Pero puedo hacer que eso funcione.
SuperJedi224
No sé Javascript, pero ¿puedes hacerlo for(i=65;i++<91;)b+=!~a.indexOf(String.fromCharCode(i));alert(!b)?
lirtosiast
Guau. Eso es incluso más corto que lo que acabo de hacer.
SuperJedi224
3

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.
Urna de pulpo mágico
fuente
3

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?
driima
fuente
2

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
)
Downgoat
fuente
1
; -; Me siento mal ahora. TBH Me gusta más TeaScript.
Conor O'Brien
2

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:")));

Conor O'Brien
fuente
@apsillers Creo que encontré el problema. Por favor, vuelva a probarlo (mi navegador no es compatible con el cajero automático ES6)
Conor O'Brien
Sí, se ve bien ahora!
apsillers
2

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;}
RCB
fuente
2

ES6, 68 bytes

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

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

Neil
fuente
Tal vez utilizando una gama de códigos de barras?
Cyoce
@Cyoce Eso me hizo pensar y probé un rango de base de 36 dígitos, pero hasta ahora todavía toma 70 bytes:s=>[...Array(x=9,26)].every(z=>RegExp((++x).toString(36),"i").test(s))
Neil
2

Scala, 59 48 46 bytes

print(('a'to'z'diff(readLine.map(_|32)))==Nil)
Ruslan
fuente
Usando 32 | en lugar de _ | 32 (arrojará una advertencia pero) eliminará un byte más
Jacob
2

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

Toby Speight
fuente
2

Perl 5, 33 bytes

$i=<>;map$=*=$i=~/$_/i,a..z;say$=
msh210
fuente
Para perl <5.10 -pl61e '$i=$_;map$\*=$i=~/$_/i,a..z}{'.
Denis Ibaev
2

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 !

Cyoce
fuente
2

Pyke, 6 bytes

l1GR-!

Pruébalo aquí!

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