Напишите функцию или программу, которая принимает в качестве входных данных строку и печатает истинное значение, если строка представляет собой панграмму (последовательность букв, содержащую хотя бы одну из каждой буквы в английском алфавите), и значение false в противном случае.

Регистр букв следует игнорировать; Если строка есть abcdefghijklmnopqrstuvwXYZ, то функция все равно должна возвращать истинное значение. Обратите внимание, что строка может содержать любые другие символы, поэтому 123abcdefghijklm NOPQRSTUVWXYZ321вернет истинное значение. Пустой ввод должен возвращать значение Falsey.

Контрольные примеры

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

Я использовал 3-байтовую "французскую" версию ( ⊆) U+2286 SUBSET OF OR EQUAL TOоператора вместо 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)

О, 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, то это панграмма (она не может быть больше 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 совпадений или нет.

Минколанг 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()}

Тот же принцип, что и в ответе Митча Шварца , но с использованием улучшений PEP 0448 для *распаковки, впервые представленных в Python 3.5.

Эта версия немного отличается от того, что я написал в своем комментарии к сообщению Митча, в том, что я превращаю цифры в буквы, а не наоборот. Это потому, что именно так я и написал свои первоначальные попытки найти решение, прежде чем обнаружил, что не смогу обойти Митча, не скопировав его подход. Так что учтите, что подправьте мою единственную оставшуюся часть оригинальности!

Руби, 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

Спасибо Васу Адари за то, что он спас мне 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 / Octave , 35 33 байта

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

Попробуйте онлайн!

Анонимная функция возвращает логический 1, если вход xявляется панграммой, или логический 0, если это не так.

По сути, он использует тот же подход, что и решение Pyth @ ThomasKwa. Разница между всеми символами в верхнем регистре букв алфавита ( 65:91) и входной строкой (преобразуется в верхний регистр). Любые символы в алфавите, но не во входной строке, возвращаются setdiff. Только если массив, возвращенный заданной разностью, пуст, строка является панграммой.

Использование верхнего регистра вместо нижнего регистра экономит пару байтов по сравнению с '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)

Сэкономили 6 байтов благодаря Томасу Ква и 10 благодаря частично ev3.

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-байтовая версия, вдохновленная ответом 05AB1E компании carusocomputing :

lÙ{Aå

Попробуйте онлайн!

Объяснение:

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

Брахилог , 4 байта

ḷo⊇Ạ

Попробуйте онлайн!

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

TeaScript , 12 байт

Sz.e»xL.I(l©

Первая запись TeaScript с тех пор, как я убил TeaScript: p

Попробуйте онлайн

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 байтов

Я уверен, что это может быть в гольфе больше.

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)

Баш, 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 ...

Попробуйте онлайн !

Пайк, 6 байт

l1GR-!

Попробуй это здесь!

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