42

एक फ़ंक्शन या प्रोग्राम लिखें जो इसके इनपुट के रूप में लेता है एक स्ट्रिंग और एक सत्य मान प्रिंट करता है यदि स्ट्रिंग एक पैंग्राम (अंग्रेजी वर्णमाला में प्रत्येक अक्षर के कम से कम एक अक्षर वाले अनुक्रम) और एक गलत मूल्य है।

पत्रों के मामले को अनदेखा किया जाना चाहिए; यदि स्ट्रिंग है abcdefghijklmnopqrstuvwXYZ, तो फ़ंक्शन को अभी भी एक सत्य मान वापस करना चाहिए। ध्यान दें कि स्ट्रिंग में कोई अन्य वर्ण हो सकते हैं, इसलिए 123abcdefghijklm NOPQRSTUVWXYZ321एक सत्य मान लौटाएगा। एक खाली इनपुट को एक गलत मूल्य वापस करना चाहिए।

परीक्षण के मामलों

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

यह कोड गोल्फ है। मानक नियम लागू होते हैं। बाइट्स में सबसे छोटा कोड जीतता है।

code-golf string decision-problem

— आर्कटुरस
स्रोत

3

प्लस पॉइंट करता है कि क्या आपका कोड यह जांच सकता है कि इनपुट एक पुन्ग्राम है या नहीं।

— टाइममीस

4

प्रश्न नाम का अनुरोध: क्या आलसी कुत्ते के ऊपर जल्दी भूरे लोमड़ी कूद गई थी?

25

पायथ, 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)

यहां फुल-प्रोग्राम, सिंगल-लाइन संस्करण का प्रयास करें ।

— lirtosiast
स्रोत

मुझे लगता है कि इनपुट में newlines के लिए इसे ठीक करने का सबसे छोटा तरीका एक फ़ंक्शन बनाना है L!-Grb0:। !-Grs.z0काम भी करेगा लेकिन लंबा है।

— FryAmTheEggman

ओह, मैंने स्ट्रिंग में \ n शामिल करने के लिए अद्यतन किए गए प्रश्न को नहीं देखा। धन्यवाद।

— २०:३० पर lirtosiast

6 बाइट्स: pyth.herokuapp.com/…

— माल्टीसेन 3

@Maltysen जबकि इनपुट से स्ट्रिंग्स को उद्धरण द्वारा सीमांकित करने की अनुमति देने पर एक (कमजोर) आम सहमति है , मुझे इस बारे में निश्चित नहीं है क्योंकि यह पायथन स्ट्रिंग सिंटैक्स की आवश्यकता में आगे बढ़ता है।

— lirtosiast 16

मैंने कभी नहीं सोचा होगा कि एक

— अल्फा

16

पर्ल 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

मैंने 4 बाइट "टेक्सस" संस्करण ( ) के बजाय ऑपरेटर के 3 बाइट "फ्रेंच" संस्करण ( ⊆) का U+2286 SUBSET OF OR EQUAL TOउपयोग किया है, (<=)जिसे इसके सामने एक अतिरिक्त स्थान की आवश्यकता होगी।

— ब्रैड गिल्बर्ट b2gills
स्रोत

12

जीएस 2, 11 9 बाइट्स

☺ 6ΘàB1."

2 बाइट्स बंद करने के लिए @MitchSchwartz के लिए धन्यवाद!

स्रोत कोड 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.

— डेनिस
स्रोत

त्वरित ब्लॉक m2( \xe9) 2 बाइट्स बचाता है।

— मिच श्वार्ट्ज

@MitchSchwartz ओह, इतना है कि के कैसे आप उन का उपयोग करें। धन्यवाद!

— डेनिस

11

जावास्क्रिप्ट ईएस 6, 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>

स्निपेट का विस्तार करें

— edc65
स्रोत

होगा a.replace(/[^A-Z]|[^a-z]/g,'')या a.replace(/[^A-Z]/gi,'')काम करेगा?

— ev3commander

2

@ ev3commander नहीं। Aऔर aएक ही पात्र बनना चाहिए, अन्यथा सेट उन्हें अलग रखेगा और आकार होगा> 26

— edc65

क्या होगा यदि आप प्रसार ऑपरेटर का उपयोग करते हैं [...a.toUpperCase().replace(/[^A-Z]/g,'')].length>25?

— स्कॉट

@ScottKaye स्पष्ट रूप से नहीं। इसे it AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA साथ आज़माएं ”

— edc65

1

@ user81655 सही है, यह काम करता है, महान। धन्यवाद। मुझे सोते समय टिप्पणियों का जवाब नहीं देना चाहिए

— edc65

9

आर 50 , 46 39 बाइट्स

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

संपादित करें tolowerजोड़कर की आवश्यकता को पूरा करता है ignore.case=TRUE( T)

— mnel
स्रोत

आर के साथ भी परिचित नहीं हैं, लेकिन ignore.case=TRUE (T)तब भी गिनती में शामिल नहीं होना चाहिए ?

— रुस्लान

2

@Ruslan यह है! यह Tअंत के रूप में है, तर्क प्लेसमेंट के लिए धन्यवाद मिलान वास्तव में तर्क का नाम निर्दिष्ट करने की आवश्यकता नहीं है (और Tडिफ़ॉल्ट उपनाम है TRUE)। यहां लिखा गया कोड आवश्यक कार्रवाई करता है, जैसे बिना किसी चीज को जोड़ने की आवश्यकता के।

— प्लेनैपस

9

ओ, 11 बाइट्स

GQ_s{n-}dS=

इसे ऑनलाइन आज़माएं।

अफसोस की बात है कि ओ में अंतर नहीं है: /

व्याख्या

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

— एक स्पैगेटो
स्रोत

6

जूलिया, 38 बाइट्स

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

यह सरल है - lowercaseअपरकेस / लोअरकेस मुद्दे से संबंधित है, 'a':'z'सभी निचले अक्षरों को रखता है, ∩प्रतिच्छेदन है, किसी भी वर्ण को हटाता है जो एक अक्षर नहीं है और, क्योंकि 'a':'z'पहले आता है, केवल प्रत्येक अक्षर में से एक होगा जो इसमें दिखाई देता है s। endofपरिणामी सरणी की लंबाई प्राप्त करने का सबसे छोटा तरीका है, और यदि यह 26 साल का है, तो यह एक पैंग्राम है (यह 26 से अधिक नहीं हो सकता है, और >25एक बाइट रिश्तेदार को बचाता है ==26)।

— ग्लेन हे
स्रोत

6

पायथन 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()))

— मिच श्वार्ट्ज
स्रोत

1

अगर मैं गलत नहीं हूं, तो अंतिम अभिव्यक्ति lambda s:set(range(65,91))<=set(map(ord,s.upper()))51 के लिए भी समान है ।

— xnor

अजगर 3.5 यहां बाइट्स बचा सकता है p=lambda s:{*range(65,91)}<={*map(ord,s.upper())}:। वैसे, मुझे इस बात पर कोई नियम नहीं मिल सकता है कि क्या lambdaसौंपा जाना चाहिए (जैसा कि आपके पहले मामले में है) या नहीं (जैसा कि आपके बाद वाले लोगों में है)। मदद?

— टिम पैडरिक

@TimPederick लैंबडा का नामकरण तब तक अनावश्यक है जब तक आपको पहले पुनरावर्ती समाधान की तरह कहीं और फ़ंक्शन का उपयोग करने की आवश्यकता न हो।

— FryAmTheEggman 16

@TimPederick यह इंगित करने के लिए धन्यवाद। मैंने अपना जवाब सिर्फ पायथन के बजाय पायथन 2 के रूप में दिया। आपको मेरा आशीर्वाद है कि यदि आप चाहें तो एक नए उत्तर के रूप में पोस्ट कर सकते हैं, जो मुझे लगता है कि सामुदायिक मानदंडों से ठीक होगा, हालांकि मुझे यकीन नहीं है।

— मिच श्वार्ट्ज

@FryAmTheEggman: स्पष्ट करने के लिए धन्यवाद। वह अंतर मेरे लिए नहीं हुआ था! मैंने नियम को समझाते हुए एक मेटा पोस्ट भी पाया है । वहाँ कुछ बातें मैंने लिखा है से दो बाइट्स जाता है ...

— टिम पेडरिक

5

रेटिना , 22 बाइट्स

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

इसे ऑनलाइन आज़माएं।

पहली पंक्ति किसी भी पत्र से मेल खाती है जो बाद में फिर से स्ट्रिंग में प्रकट नहीं होती है। यह सुनिश्चित करता है कि हम प्रत्येक अक्षर को एक बार में मेल नहीं खाते, चाहे वह कितनी भी बार क्यों न हो। मैच मोड डिफ़ॉल्ट रूप से स्ट्रिंग को मिल रहे मैचों की संख्या से बदल देगा। इसलिए दूसरे चरण में, हम 26पहले इनपुट के परिणाम के खिलाफ मेल खाते हैं , जो 0या तो या 1, इस बात पर निर्भर करेगा कि हमें अधिकतम 26 मैच मिले या नहीं।

— मार्टिन एंडर
स्रोत

4

मिंकोलंग 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.

— एलेंडिया स्ट्राटन
स्रोत

4

पायथन 3.5, 47 बाइट्स

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

मिच श्वार्ट्ज के उत्तर के रूप में समान सिद्धांत , लेकिन अनपैकिंग के लिए पीईपी 0448 संवर्द्धन का उपयोग करते हुए *, पहले पायथन 3.5 में पेश किया गया।

यह संस्करण मिच की पोस्ट पर अपनी टिप्पणी में मैंने जो लिखा है, उससे थोड़ा अलग है, इसमें मैं संख्याओं को अक्षरों में बदल देता हूं, इसके विपरीत। ऐसा इसलिए है क्योंकि मैंने एक समाधान में अपने मूल प्रयासों को लिखा है, इससे पहले कि मैं उसके दृष्टिकोण की नकल के बिना गोल्फ मिच को आउट नहीं कर सका। तो विचार करें कि मेरी मौलिकता के बचे हुए हिस्से को तोड़ दें!

— टिम पेडरिक
स्रोत

4

रूबी, ४१ ३३

->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 बाइट बचाने के लिए वासु अडारी का धन्यवाद

— एलेक्सिस एंडरसन
स्रोत

2

आप अपने regex को अज्ञानी बनाकर 8 बाइट्स बचा सकते हैं।

— वासु अडारी

4

आर, 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

— plannapus
स्रोत

4

MATLAB / ऑक्टेव , 35 33 बाइट्स

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

इसे ऑनलाइन आज़माएं!

अनाम फ़ंक्शन एक तार्किक 1 लौटाता है यदि इनपुट xएक पैंग्राम या एक तार्किक 0 है यदि यह नहीं है।

अनिवार्य रूप से यह @ थॉमसकेवा के पाइथ समाधान के समान दृष्टिकोण का उपयोग करता है। ऊपरी वर्ण वर्णमाला श्रेणी ( 65:91) और इनपुट स्ट्रिंग (ऊपरी मामले में परिवर्तित) में सभी वर्णों के बीच का अंतर । कोई भी वर्ण जो वर्णमाला में है लेकिन इनपुट स्ट्रिंग में नहीं है setdiff। यदि सेट अंतर द्वारा वापस किया गया सरणी खाली है तो ही स्ट्रिंग पैंग्राम है।

निचले मामले के बजाय ऊपरी मामले का उपयोग करने से कुछ बाइट्स की तुलना में बचत होती है 'a':'z'क्योंकि सीमा बनाने के लिए ASCII मान का उपयोग किया जा सकता है।

— टॉम बढ़ई
स्रोत

बहुत बढ़िया जवाब! मेरा 10 बाइट्स लंबा था

— लुइस मेंडू

4

हास्केल , 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तुलना से पहले के तत्वों को संशोधित करने की अनुमति देता है - इस मामले में, उन्हें ऊपरी मामले में कवर करें।

— Laikoni
स्रोत

3

जाप , 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

— ETHproductions
स्रोत

3

सीजेएम, 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.

— रेटो कोराडी
स्रोत

3

जावास्क्रिप्ट, 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 के लिए धन्यवाद।

— SuperJedi224
स्रोत

क्या b = [b] के लिए 0 काम करेगा?

— ev3commander

इस दृष्टिकोण के साथ नहीं। लेकिन मैं वह काम करने में सक्षम हो सकता हूं।

— SuperJedi224

मैं जावास्क्रिप्ट नहीं जानता, लेकिन क्या आप कर सकते हैं for(i=65;i++<91;)b+=!~a.indexOf(String.fromCharCode(i));alert(!b)?

— lirtosiast

वाह। जो मैंने अभी किया उससे भी कम है।

— SuperJedi224

3

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.

— जादू ऑक्टोपस Urn
स्रोत

3

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 बाइट संस्करण, carusocomputing के 05AB1E उत्तर से प्रेरित है :

lÙ{Aå

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

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

— driima
स्रोत

3

ब्रेकीलॉग , 4 बाइट्स

ḷo⊇Ạ

इसे ऑनलाइन आज़माएं!

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

— असंबंधित स्ट्रिंग
स्रोत

2

टीस्क्रिप्ट , 12 बाइट्स

Sz.e»xL.I(l©

जब से मैंने टीस्क्रिप्ट को मार डाला, तब से पहला टीस्क्रिप्ट पोस्ट : पी

इसे ऑनलाइन आज़माएं

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
)

— Downgoat
स्रोत

1

; -; अब मुझे बुरा लग रहा है। टीबीएच मुझे टीस्क्रिप्ट सबसे ज्यादा पसंद है।

— कॉनर ओ'ब्रायन

2

जावास्क्रिप्ट ईएस 6, 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:")));

स्निपेट का विस्तार करें

— कोनोर ओ ब्रायन
स्रोत

@ अंतराल मुझे लगता है कि मुझे समस्या मिली। कृपया इसे फिर से जांचें (मेरा ब्राउज़र ES6 atm का समर्थन नहीं करता है)

— कॉनर ओ'ब्रायन

हाँ, अब अच्छा लग रहा है!

— अप्सिलर्स 19

2

सी, 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;}

— आरसीबी
स्रोत

2

ईएस 6, 68 बाइट्स

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

यह स्ट्रिंग भयानक रूप से बेकार है, लेकिन मुझे कोई बेहतर तरीका नहीं पता है।

— नील
स्रोत

हो सकता है कि चारकोड की एक सीमा का उपयोग कर रहे हों?

— साइओस

@ मुझे लगता है कि मैं सोच रहा था और मैंने 36 अंकों के आधार की एक श्रृंखला की कोशिश की, लेकिन अभी तक यह 70 बाइट्स लेता है:s=>[...Array(x=9,26)].every(z=>RegExp((++x).toString(36),"i").test(s))

— नील

2

स्काला, 59 48 46 बाइट्स

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

— रुस्लान
स्रोत

32 का उपयोग करना | इसके बजाय _ | 32 वसीयत (एक चेतावनी उपज लेकिन) एक और बाइट से दाढ़ी

— याकूब

2

बैश, 45 42 बाइट्स

41 बाइट प्रोग्राम, प्लस 1 क्योंकि इसे साथ होना चाहिए bash -e:

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

आश्चर्यजनक रूप से, मैंने कोई उद्धरण वर्णों के साथ एक बैश उत्तर प्रबंधित किया! (हाँ, मैंने इनपुट के साथ शुरुआत की -fऔर इस तरह की जाँच की)।

यह एक स्थान जहां लोअर केस अंग्रेज़ी अक्षरों से सटे हैं मान लिया गया है aकरने के लिए z। इनपुट कार्यक्रम के पहले तर्क के माध्यम से है।

जिस तरह से यह काम करता है, प्रत्येक अक्षर अक्षर के लिए $i, हम परीक्षण करते हैं कि क्या स्ट्रिंग में है $iया इसके ऊपरी मामले में ${i^}अन्य सभी वर्णों को हटाकर समतुल्य है। यदि यह रिक्त स्ट्रिंग में परिणाम करता है, तो इनपुट में वह पत्र नहीं था, और हम 1(झूठे) से बाहर निकलते हैं । यदि हमारे पास एक गैर-रिक्त परिणाम है, तो हमने परीक्षण पास किया और अगले पत्र पर चले गए। यदि इनपुट स्ट्रिंग में हर अंग्रेजी अक्षर होता है, तो हम प्रोग्राम के अंत तक पहुंच जाएंगे, इस प्रकार 0(सत्य) से बाहर निकल जाएंगे ।

— टोबी स्पाईट
स्रोत

2

पर्ल 5, 33 बाइट्स

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

— msh210
स्रोत

पर्ल के लिए <5.10 -pl61e '$i=$_;map$\*=$i=~/$_/i,a..z}{'।

— डेनिस इबाएव

2

प्लैटापार , 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 होगा ...

इसे ऑनलाइन आज़माएं !

— Cyoce
स्रोत

2

Pyke, 6 बाइट्स

l1GR-!

यहाँ यह कोशिश करो!

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

— नीला
स्रोत

क्या यह पंग्राम है?

पायथ, 7 बाइट्स

पर्ल 6 , 20 बाइट्स

जीएस 2, 11 9 बाइट्स

यह काम किस प्रकार करता है

जावास्क्रिप्ट ईएस 6, 51 57

आर 50 , 46 39 बाइट्स

ओ, 11 बाइट्स

व्याख्या

जूलिया, 38 बाइट्स

पायथन 2, 53 51 बाइट्स

रेटिना , 22 बाइट्स

मिंकोलंग 0.14 , 18 बाइट्स

व्याख्या

पायथन 3.5, 47 बाइट्स

रूबी, ४१ ३३

प्रयोग

आर, 53 45 बाइट्स

MATLAB / ऑक्टेव , 35 33 बाइट्स

हास्केल , 59 56 53 51 बाइट्स

जाप , 14 बाइट्स

यह काम किस प्रकार करता है

सीजेएम, 11 बाइट्स

जावास्क्रिप्ट, 110 109 99 95 93 बाइट्स

05AB1E , 4 बाइट्स (संभवतः गैर-प्रतिस्पर्धात्मक)

2sable , 6 5 बाइट्स

ब्रेकीलॉग , 4 बाइट्स

टीस्क्रिप्ट , 12 बाइट्स

Ungolfed

जावास्क्रिप्ट ईएस 6, 124 114 113 बाइट्स

सी, 107 बाइट्स

ईएस 6, 68 बाइट्स

स्काला, 59 48 46 बाइट्स

बैश, 45 42 बाइट्स

पर्ल 5, 33 बाइट्स

प्लैटापार , 14 बाइट्स

Pyke, 6 बाइट्स