Scrivi una funzione o un programma che accetta come input una stringa e stampa un valore di verità se la stringa è un pangramma (una sequenza di lettere contenente almeno una di ciascuna lettera dell'alfabeto inglese) e un valore di falso in caso contrario.

Il caso delle lettere dovrebbe essere ignorato; Se la stringa è abcdefghijklmnopqrstuvwXYZ, la funzione dovrebbe comunque restituire un valore di verità. Nota che la stringa può contenere qualsiasi altro carattere al suo interno, quindi 123abcdefghijklm NOPQRSTUVWXYZ321restituirebbe un valore di verità. Un input vuoto dovrebbe restituire un valore false.

Casi test

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

Questo è il codice golf. Si applicano le regole standard. Vince il codice più breve in byte.

Pyth, 7 byte

L!-Grb0

Spiegazione:

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)

Prova qui la versione a linea singola a programma completo .

Perl 6 , 20 byte

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

utilizzo:

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

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

Ho usato la versione "francese" ( ⊆) a 3 byte U+2286 SUBSET OF OR EQUAL TOdell'operatore invece della versione "texas" a 4 byte ( (<=)) che avrebbe richiesto anche uno spazio aggiuntivo di fronte.

GS2, 11 9 byte

☺ 6ΘàB1."

Grazie a @MitchSchwartz per giocare a golf con 2 byte!

Il codice sorgente utilizza la codifica CP437. Provalo online!

Come funziona

☺              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

Modifica 6 byte salva thx @ user81655

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

Test snippet

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 byte

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

Modifica elimina la necessità toloweraggiungendo ignore.case=TRUE( T)

O, 11 byte

GQ_s{n-}dS=

Provalo online.

Purtroppo, O non ha una differenza prefissata: /

Spiegazione

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 byte

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

Questo è semplice: lowercaseaffronta il problema delle maiuscole / minuscole, 'a':'z'contiene tutte le lettere minuscole, ∩è l'intersezione, rimuove qualsiasi carattere che non sia una lettera e, poiché 'a':'z'viene prima, avrà solo una di ogni lettera che appare in s. endofè il modo più breve per ottenere la lunghezza dell'array risultante e, se è 26, è un pangram (non può essere più di 26 e >25salva un byte rispetto a ==26).

Python 2, 53 51 byte

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

Soluzioni alternative:

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

Grazie a xnor per aver sottolineato che i set hanno un <=operatore, per un 51 alternativo:

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

Retina , 22 byte

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

Provalo online.

La prima riga corrisponde a qualsiasi lettera che non appare più in seguito nella stringa. Ciò garantisce che non abbiniamo ogni lettera al massimo una volta, indipendentemente dalla frequenza con cui si verifica. La modalità di corrispondenza sostituirà di default la stringa con il numero di corrispondenze trovate. Quindi nella seconda fase, ci 26confrontiamo con il risultato del primo input, che darà o 0o 1, a seconda che abbiamo trovato il massimo di 26 partite o meno.

Minkolang 0,14 , 18 byte

$o7$ZsrlZ'26'$ZN.

Provalo qui.

Spiegazione

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

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

Stesso principio della risposta di Mitch Schwartz , ma utilizzando i miglioramenti PEP 0448 per il *disimballaggio, introdotto per la prima volta in Python 3.5.

Questa versione differisce leggermente da ciò che ho scritto nel mio commento al post di Mitch, in quanto trasformo i numeri in lettere anziché viceversa. Questo perché ho scritto i miei tentativi originali di trovare una soluzione, prima di scoprire che non potevo superare Mitch senza copiarlo apertamente. Quindi considera che ottimizza il mio unico brandello di originalità!

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

Grazie a Vasu Adari per avermi salvato 8 byte

R, 53 45 byte

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

Vecchia versione a 53 byte:

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 byte

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

Provalo online!

La funzione anonima restituisce un 1 logico se l'input xè un pangram o uno 0 logico se non lo è.

Sostanzialmente utilizza lo stesso approccio della soluzione Pyth di @ ThomasKwa. La differenza impostata tra tutti i caratteri nell'intervallo alfabetico maiuscolo ( 65:91) e la stringa di input (convertita in maiuscolo). Tutti i caratteri che si trovano nell'alfabeto ma non nella stringa di input vengono restituiti da setdiff. Solo se l'array restituito dalla differenza impostata è vuoto, la stringa è un pangram.

L'uso di lettere maiuscole anziché minuscole consente di risparmiare un paio di byte rispetto a 'a':'z'perché è possibile utilizzare il valore ASCII per creare l'intervallo.

Haskell , 59 56 53 51 byte

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

Provalo online!

Spiegazione:

Dare una stringa di input s, per ciascuno anell'intervallo da 65 a 90 (i codici ASCII per Aa Z) viene verificato se qualsiasi carattere in sè uguale a a(il carattere maiuscolo) o a+32(il carattere minuscolo), convertito in un carattere di toEnum. Questo genera un elenco di booleani. andcontrolla se sono tutti True.

Vecchia versione:

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

Per ogni lettera dell'alfabeto maiuscola, controlla se qualche lettera smaiuscola è uguale ad essa. any(==a)sè lo stesso elem a sma consente di modificare gli elementi di sprima del confronto - in questo caso, convertirli in maiuscolo.

Japt , 14 byte

#ao#{ e@Uv fXd

Provalo online!

Come funziona

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

'[,65>qeu-!

Questo è un programma completo. Provalo online .

Spiegazione:

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

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

6 byte salvati grazie a Thomas Kwa e 10 grazie in parte a ev3.

05AB1E , 4 byte (probabilmente non in competizione)

lêAå

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

2 cifre , 6 5 byte

Versione a 6 byte:

AIl-g_

Provalo online!

Spiegazione:

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)

Versione a 5 byte, ispirata alla risposta 05AB1E di carusocomputing :

lÙ{Aå

Provalo online!

Spiegazione:

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

Brachylog , 4 byte

ḷo⊇Ạ

Provalo online!

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

TeaScript , 12 byte

Sz.e»xL.I(l©

Primo post su TeaScript da quando ho ucciso TeaScript: p

Provalo 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 byte

Sono sicuro che questo può essere giocato di più.

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 funzione anonima.

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 byte

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

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

Quella stringa sembra terribilmente dispendiosa, ma non conosco alcun modo migliore.

Scala, 59 48 46 byte

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

Bash, 45 42 byte

Programma da 41 byte, più 1 perché deve essere invocato con bash -e:

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

Sorprendentemente, ho gestito una risposta Bash senza caratteri di citazione! (sì, ho controllato con input che iniziano con -fe simili).

Ciò presuppone un'impostazione internazionale in cui le lettere inglesi minuscole sono contigue da aa z. L'input avviene tramite il primo argomento del programma.

Il modo in cui funziona è, per ogni lettera alfabetica $i, testiamo se la stringa contiene $io il suo equivalente maiuscolo ${i^}rimuovendo tutti gli altri caratteri. Se questo risulta nella stringa vuota, l'input non contiene quella lettera e usciamo con 1(false). Se abbiamo un risultato non vuoto, abbiamo superato il test e passiamo alla lettera successiva. Se la stringa di input contiene tutte le lettere inglesi, raggiungeremo la fine del programma, uscendo così con 0(true).

Perl 5, 33 byte

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

PlatyPar , 14 byte

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

Spiegazione (funzionalità di visualizzazione dello stack in arrivo!):

               ## 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 avessi una ridicola funzione "spingi tutte le lettere dell'alfabeto" questo sarebbe 10 ...

Provalo online !

Pyke, 6 byte

l1GR-!

Provalo qui!

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