सबसे छोटी पैंग्रामेटिक खिड़की

15

एक पैंग्राम एक वाक्य या अंश है जिसमें वर्णमाला के सभी छब्बीस अक्षर शामिल हैं, जैसा कि इस कोड गोल्फ चैलेंज में दिखाया गया है । हालाँकि, एक पैंग्रामैटिक विंडो पाठ के कुछ खंड के रूप में एक पैंग्राम है, जो एक शब्द के माध्यम से आधे रास्ते में समाप्त या शुरू हो सकता है, जो एक बड़े काम के भीतर कहीं पाया जाता है। ये स्वाभाविक रूप से हर जगह होते हैं, सच्चे पैंग्राम के उचित उपसमुच्चय होने के नाते, इसलिए अगर किसी चीज़ में एक पैंग्रामैटिक खिड़की होती है तो यह सत्यापित करना उबाऊ होगा और यह पहले भी किया गया था।

तो, हम सबसे छोटे को खोजने में रुचि रखते हैं जो पाठ की दी गई लंबाई के आधार पर दिया गया हो! बाइट्स में सबसे कम संभव कोड में, विषय को फिट करने के लिए।

नियम और दिशानिर्देश

  • इनपुट के रूप में एक स्ट्रिंग प्राप्त करें और यदि एक है तो इनपुट की सबसे छोटी पैंग्रामेटिक विंडो की स्ट्रिंग लौटाएं। यदि नहीं है, तो या तो एक बूलियन झूठी या एक खाली स्ट्रिंग लौटें।
  • कोई स्ट्रिंग एक पैंग्रामेटिक खिड़की है या नहीं केस-असंवेदनशील है और केवल 26 अक्षरों पर निर्भर करता है, न कि किसी विराम चिह्न या संख्या या अन्य विषम प्रतीकों पर।
  • इसी तरह, एक पैंग्रामेटिक विंडो की अक्षर लंबाई कुल संख्या है कि इसमें कितने अक्षर अकेले दिखाई देते हैं, और न केवल हर वर्ण की संख्या। इस गणना के आधार पर लौटाया गया मान सबसे छोटा होना चाहिए। हम भाषाविद् हैं, आखिरकार, प्रोग्रामर नहीं।
  • हालाँकि, एक पैंग्रामेटिक विंडो का आउटपुट इनपुट का एक सटीक विकल्प होना चाहिए, जिसमें एक ही कैपिटलाइज़ेशन और विराम चिह्न शामिल हैं, आदि।
  • यदि एक ही अक्षर की लंबाई वाली कई छोटी-बड़ी पैंग्रामेटिक खिड़कियां हैं, तो उनमें से किसी एक को लौटा दें।

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

'This isn't a pangram.'
==> False

'Everyone knows about that infamous Quick-Brown-Fox (the one who jumped over some lazy ignoramus of a dog so many years ago).'
==> 'Quick-Brown-Fox (the one who jumped over some lazy ig'

'"The five boxing wizards jump quickly." stated Johnny, before beginning to recite the alphabet with a bunch of semicolons in the middle. "ABCDEFGHI;;;;;;;;;;;;;;;JKLMNOPQRSTUVWXYZ!" he shouted to the heavens.'
==> 'ABCDEFGHI;;;;;;;;;;;;;;;JKLMNOPQRSTUVWXYZ'
code-golf  string 
— Reecer6
स्रोत
1
अंतिम परीक्षण मामले के लिए, क्यों नहीं The five boxing wizards jump quicklyलौटाया गया?
— ब्लू
1
दूसरे मामले के लिए, क्या आपको पूर्ववर्ती स्थान की अनुमति है Q? यह अक्षर गणना में नहीं जोड़ा जाता है।
— नील
2
@ मुडफिश क्योंकि इसमें 31 अक्षर हैं, जबकि अपेक्षित आउटपुट में केवल 26 हैं।
— मार्टिन एंडर
4
अच्छा पहला सवाल!
— R
2
हां। कोई कारण नहीं होना चाहिए। सवाल की भावना में "सच" न्यूनतम लेना , लेकिन यह आवश्यक नहीं है।
— रेकर

जवाबों:

6

पायथ, 20 16 14 बाइट्स

hol@GNf!-GrT0.:

स्पष्टीकरण:

             .: - substrings of input()
      f!-GrT0   - filter to ones which contain the alphabet
 ol@GN          - sort by number of alphabetical chars
h               - ^[0]

      f!-GrT0   - filter(lambda T:V, substrings)
          rT0   -    T.lower()
        -G      -   alphabet-^
       !        -  not ^

 o              - sort(^, lambda N:V)
   @GN          -   filter_presence(alphabet, N)
  l             -  len(^)

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

जब कोई सही समाधान नहीं होता है, तो प्रोग्राम स्टडआउट के लिए आउटपुट के साथ एक त्रुटि के साथ बाहर निकलता है।

— नीला
स्रोत
आपको लगता है कि आपने पहले कोड ब्लॉक में कोड अपडेट नहीं किया है। !-GrT0मैं फ़िल्टर स्थिति के लिए भी छोटा हूं, मेरा मानना ​​है। मुझे भी लगता है कि आपको lठीक तरह से काम करने की आवश्यकता है।
— फ्राईमईएग्गमैन
ओह, मुझे याद आया, मेरा मतलब था लिंक। आपके लिंक में अभी भी आपके पास है l, और इसके बिना आपको अलग-अलग परिणाम मिलते हैं । मेरा मानना ​​है कि समस्या बार-बार पत्र है, लेकिन मैं 100% निश्चित नहीं हूं।
— FryAmTheEggman
तो यह बात करता है - और अनुकूलन के लिए धन्यवाद!
— ब्लू
2

रूबी, 100 बाइट्स

यदि कोई विंडो नहीं मिलती है, तो nil लौटाता है। 

->s{r=0..s.size
(r.map{|i|s[i,r.find{|j|(?a..?z).all?{|c|s[i,j]=~/#{c}/i}}||0]}-['']).min_by &:size}
— मान स्याही
स्रोत
2

जावास्क्रिप्ट (ईएस 6), 139 138 136 बाइट्स

s=>[r=l="",...s].map((_,b,a)=>a.map((c,i)=>i>b&&(t+=c,z=parseInt(c,36))>9&&(v++,n+=!m[z],m[z]=n<26||l&&v>l||(r=t,l=v)),t=m=[],v=n=0))&&r

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

दांतेदार बना हुआ

var solution =

s=>
  [r=l="",...s].map((_,b,a)=> // b = index of start of window to check
    a.map((c,i)=>
      i>b&&(
        t+=c,
        z=parseInt(c,36)
      )>9&&(
        v++,
        n+=!m[z],
        m[z]=
          n<26||
          v>l&&l||(
            r=t,
            l=v
          )
      ),
      t=m=[],
      v=n=0
    )
  )
  &&r
<textarea cols="70" rows="6" id="input">Everyone knows about that infamous Quick-Brown-Fox (the one who jumped over some lazy ignoramus of a dog so many years ago).</textarea><br /><button onclick="result.textContent=solution(input.value)">Go</button><pre id="result"></pre>
स्निपेट का विस्तार करें

— user81655
स्रोत
क्या आप उपयोग नहीं कर सकते [r=l="",...s].map((_,b,a)=>?
— नील
@ धन्यवाद, मैं हमेशा mapफ़ंक्शन में तीसरे पैरामीटर के बारे में भूल जाता हूं ।
— user81655
मुझे लगता है कि @ edc65 इसे हरा सकता है, हालांकि, मैंने उसके विस्फोटित पदार्थों के लिए कोड को उसके पंग्राम परीक्षक के साथ विलय कर दिया और एक 134 बाइट फ़ंक्शन के साथ समाप्त हो गया।
— नील
मेरा सर्वश्रेष्ठ अब तक 142 है
— edc65
अफसोस की बात है कि मैं इसे बचाने के लिए नहीं सोचा था और मेरा पीसी दुर्घटनाग्रस्त हो गया था इसलिए अब मुझे नहीं पता कि मेरे पास क्या था; अब मैं जो सबसे अच्छा कर सकता हूं वह है 138 बाइट्स।
— नील
2

PowerShell v2 +, 218 बाइट्स

param($a)$z=@{};(0..($b=$a.length-1)|%{($i=$_)..$b|%{-join$a[$i..$_]}})|%{$y=$_;$j=1;65..90|%{$j*=$y.ToUpper().IndexOf([char]$_)+1};if($j){$z[($y-replace'[^A-Za-z]').Length]=$y}}
($z.GetEnumerator()|sort Name)[0].Value

हाँ, इसलिए हेरफेर को प्रतिस्थापित करना (कोई बिल्ट-इन नहीं है) वास्तव में पॉवरशेल का मजबूत सूट नहीं है ...

हम इनपुट लेते हैं param($a)और एक नया खाली हैशटेबल सेट करते हैं $z। यह हमारे उम्मीदवार पैंग्राममैटिक सबस्ट्रिंग का भंडारण होगा।

एक्सप्लोडेड सबस्ट्रिंग से मेरे कोड के एक मामूली संशोधन का उपयोग करते हुए , हम इनपुट के सभी सबस्ट्रिंग का निर्माण करते हैं। हां, यहां तक ​​कि एक-चरित्र विराम चिह्न-केवल सबस्ट्रिंग। यह कोड-गोल्फ है , सबसे तेज-कोड नहीं । ;-)

उन सब पदार्थों को परिच्छेदों में कूटबद्ध किया जाता है और दूसरे पाश में ढकेल दिया जाता है |%{...} । हम अस्थायी रूप $yसे अपने वर्तमान विकल्प के लिए सेट करते हैं, एक सहायक काउंटर सेट करते हैं $j, और 65..90|%{...}कैपिटल अक्षरों के लिए आसानी से ASCII चार कोड पर एक और लूप शुरू करते हैं। प्रत्येक आंतरिक लूप, हम लेते हैं $y, इसे सभी बड़े अक्षर बनाते हैं, और .IndexOfउस विशेष वर्ण को बाहर निकालते हैं । चूंकि यह -1नहीं मिला है, तो हम +1इसे गुणा करने से पहले परिणाम देंगे $j। यह सुनिश्चित करता है कि यदि कोई एक वर्ण नहीं मिला है, तो $jवह शून्य के बराबर होगा।

जो बिल्कुल वही है जो ifसभी के बारे में है। यदि $jगैर-शून्य है, तो इसका मतलब है कि प्रत्येक अक्षर को कम से कम एक बार प्रतिस्थापन में पाया गया था $y, इसलिए हमें इसे अपने उम्मीदवार पूल में जोड़ना होगा। हम प्रत्येक गैर-पत्र को कुछ भी नहीं लेने $yऔर लेने के द्वारा ऐसा करते हैं -replace, जो हमें उस स्थानापन्न की अक्षर-लंबाई मिलती है। हम हैशटेबल में उस इंडेक्स के रूप में उपयोग करते हैं $zऔर $yउस इंडेक्स पर स्टोर करते हैं। यह एक ही अक्षर-लंबाई के ओवरराइटिंग सब्सट्रेट का क्विकर है, जो मूल स्ट्रिंग में "फर्स्टेस्ट" होता है, लेकिन इसे नियमों द्वारा अनुमति दी जाती है, क्योंकि हम केवल पत्र-लंबाई के बारे में चिंतित हैं।

अंत में, हमें $zसबसे छोटे के माध्यम से छाँटना और निकालना होगा। हमें अंदर.GetEnumerator की वस्तुओं पर छांटने के लिए कॉल का उपयोग करना होगा $z , फिर sortउन Name(यानी, ऊपर से लंबाई सूचकांक), [0]वें एक (यानी, सबसे कम) का चयन करते हुए , और इसके .Value(यानी, विकल्प) आउटपुट करना है । यदि ऐसा कोई विकल्प नहीं है, तो यह त्रुटि ( Cannot index into a null array) को अनुक्रमित करने का प्रयास करता है $z, और आउटपुट कुछ भी नहीं करता है, जो कि PowerShell में गलत है। (नीचे तीसरे परीक्षण के मामले में [bool]यह दिखाने के लिए एक स्पष्ट डाली है )

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

PS C:\Tools\Scripts> .\golfing\shortest-pangrammatic-window.ps1 '"The five boxing wizards jump quickly." stated Johnny, before beginning to recite the alphabet with a bunch of semicolons in the middle. "ABCDEFGHI;;;;;;;;;;;;;;;JKLMNOPQRSTUVWXYZ!" he shouted to the heavens.'
ABCDEFGHI;;;;;;;;;;;;;;;JKLMNOPQRSTUVWXYZ!" 

PS C:\Tools\Scripts> .\golfing\shortest-pangrammatic-window.ps1 'Everyone knows about that infamous Quick-Brown-Fox (the one who jumped over some lazy ignoramus of a dog so many years ago).'
Quick-Brown-Fox (the one who jumped over some lazy ig

PS C:\Tools\Scripts> [bool](.\golfing\shortest-pangrammatic-window.ps1 "This isn't a pangram.")
Cannot index into a null array.
At C:\Tools\Scripts\golfing\shortest-pangrammatic-window.ps1:2 char:1
+ ($z.GetEnumerator()|sort Name)[0].Value
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (:) [], RuntimeException
    + FullyQualifiedErrorId : NullArray

False
— AdmBorkBork
स्रोत
2

हास्केल, 180 बाइट्स

यह कठिन था, लेकिन आयात के बिना वास्तव में मजेदार था।

l=['a'..'z']
u=['A'..'Z']
f&[]=[];f&x=x:f&f x
g#h=(.g).h.g
f x|v<-[y|y<-(tail&)=<<(init&x),and$zipWith((`elem`y)#(||))l u]=last$[]:[z|z<-v,all((length.filter(`elem`l++u))#(<=)$z)v]

बहुत कम गोल्फ:

lowerCase = ['a'..'z']
upperCase = ['A'..'Z']

f & x = takeWhile (not . null) $ iterate f x

(#) = flip on

subStrings x = (tail &) =<< (init & x)

pangram p = and $ zipWith ((`elem` p) # (||)) lowerCase upperCase

leqLetters x y = (length . filter (`elem` lowerCase ++ upperCase)) # (<=)

fewestLetters xs = [ x | x <- xs, all (leqLetters x) xs]

safeHead [] = ""
safeHead xs = head xs

f x = safeHead . fewestLetters . filter pangram . subStrings

आश्चर्य, आश्चर्य: यह वास्तव में धीमा है।

— माइकल क्लेन
स्रोत
2

Oracle SQL 11.2, 461 बाइट्स

WITH s AS (SELECT SUBSTR(:1,LEVEL,1)c,LEVEL p FROM DUAL CONNECT BY LEVEL<=LENGTH(:1)),v(s,f,l)AS(SELECT c,p,p FROM s UNION ALL SELECT s||c,f,p FROM v,s WHERE p=l+1),c AS(SELECT CHR(96+LEVEL)c FROM DUAL CONNECT BY LEVEL<27),a AS(SELECT LISTAGG(c)WITHIN GROUP(ORDER BY 1) a FROM c)SELECT MIN(s)KEEP(DENSE_RANK FIRST ORDER BY LENGTH(s)-NVL(LENGTH(TRANSLATE(LOWER(s),' '||a,' ')),0))FROM(SELECT s,f,SUM(SIGN(INSTR(LOWER(s),c)))x FROM v,c GROUP BY s,f),a WHERE x=26;

संयुक्त राष्ट्र के golfed

WITH s AS (SELECT SUBSTR(:1,LEVEL,1)c,LEVEL p FROM DUAL CONNECT BY LEVEL<=LENGTH(:1))
,v(s,f,l) AS
(
  SELECT c,p,p FROM s
  UNION ALL
  SELECT s||c,f,p FROM v,s WHERE p=l+1 
)
,c AS(SELECT CHR(96+LEVEL)c FROM DUAL CONNECT BY LEVEL<27)
,a AS(SELECT LISTAGG(c)WITHIN GROUP(ORDER BY 1) a FROM c)
SELECT MIN(s)KEEP(DENSE_RANK FIRST ORDER BY LENGTH(s)-NVL(LENGTH(TRANSLATE(LOWER(s),' '||a,' ')),0))
FROM(SELECT s,f,SUM(SIGN(INSTR(LOWER(s),c)))x FROM v,c GROUP BY s,f),a
WHERE x=26

sदृश्य अक्षरों में इनपुट विभाजन और भी हर किरदार की स्थिति देता है।

पुनरावर्ती दृश्य vइनपुट
s के प्रत्येक विकल्प को प्रतिस्थापित करता है, सबस्ट्रिंग
f है जो कि प्रतिस्थापित पदार्थ के प्रथम वर्ण की
स्थिति से है, अंतिम स्थान से जोड़ा गया अंतिम वर्ण की स्थिति

cदृश्य एक समय में वर्णमाला, एक पत्र देता है

aदृश्य वर्णमाला एक एकल स्ट्रिंग के रूप में श्रेणीबद्ध रिटर्न

SELECT s,f,SUM(SIGN(INSTR(LOWER(s),c))
प्रत्येक में मौजूद अलग-अलग अक्षरों की संख्या को प्रतिस्थापित करने के लिए
INSTRरिटर्न, सबरिंग में एक पत्र की स्थिति देता है, 0 यदि प्रस्तुत नहीं है
SIGNतो 1 प्रस्तुत करें > स्थिति> 0, 0 अगर पॉज़ = 0

WHERE x=26
पूरे वर्णमाला वाले विकल्प को फिल्टर करता है

TRANSLATE(LOWER(s),' '||a,' ')
हर अक्षर को प्रतिस्थापित से हटाता है

LENGTH(s)-NVL(LENGTH(TRANSLATE(LOWER(s),' '||a,' ')
अक्षरों में लंबाई सबस्ट्रिंग की लंबाई है अक्षरों के बिना उपशीर्षक की लंबाई

SELECT MIN(s)KEEP(DENSE_RANK FIRST ORDER BY LENGTH(s)-NVL(LENGTH(TRANSLATE(LOWER(s),' '||a,' ')),0))
केवल छोटे अक्षर की गिनती के साथ विकल्प रखता है।
यदि एक से अधिक है, तो पहले वाले को, बढ़ते हुए तार के रूप में क्रमबद्ध किया जाता है

— Jeto
स्रोत
2

पायथन 3, 171, 167, 163, 157 , 149 बाइट्स।

सहेजे गए 4 बाइट डीएसएम के लिए धन्यवाद।
सहेजे गए 8 बाइट्स RootTwo के लिए धन्यवाद।

lambda x,r=range:min([x[i:j]for i in r(len(x))for j in r(len(x))if{*map(chr,r(65,91))}<={*x[i:j].upper()}]or' ',key=lambda y:sum(map(str.isalpha,y)))

अक्षरों की संख्या के आधार पर क्रमबद्ध होने से मुझे मार रहा है।

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

assert f("This isn't a pangram.") == ' '
assert f("Everyone knows about that infamous Quick-Brown-Fox (the one who jumped over some lazy ignoramus of a dog so many years ago).") == ' Quick-Brown-Fox (the one who jumped over some lazy ig', f("Everyone knows about that infamous Quick-Brown-Fox (the one who jumped over some lazy ignoramus of a dog so many years ago).")
assert f('"The five boxing wizards jump quickly." stated Johnny, before beginning to recite the alphabet with a bunch of semicolons in the middle. "ABCDEFGHI;;;;;;;;;;;;;;;JKLMNOPQRSTUVWXYZ!" he shouted to the heavens.') == '. "ABCDEFGHI;;;;;;;;;;;;;;;JKLMNOPQRSTUVWXYZ', f('"The five boxing wizards jump quickly." stated Johnny, before beginning to recite the alphabet with a bunch of semicolons in the middle. "ABCDEFGHI;;;;;;;;;;;;;;;JKLMNOPQRSTUVWXYZ!" he shouted to the heavens.')
— मॉर्गन थ्रैप
स्रोत
.upper()महत्वपूर्ण फ़ंक्शन में मत सोचो ।
— रूटट्वो
@RootTwo उफ़, हाँ, तुम सही हो। धन्यवाद।
— मॉर्गन थ्रैप
1

पॉवरशेल (v4), 198 156 बाइट्स

param($s)
-join(@(1..($y=$s.Length)|%{$w=$_
0..$y|%{(,@($s[$_..($_+$w)]))}}|?{($_-match'[a-z]'|sort -U).Count-eq26}|sort -Pr {($_-match'[a-z]').count})[0])


# Previous 198 byte golf
$a,$b,$c=@(1..($s="$args").Length|%{$w=$_
0..($s.Length-$w)|%{if((($t=$s[$_..($_+$w)]-match'[a-z]')|sort -u).Count-eq26){(,@($t.Length,$_,$w))}}}|sort -pr{$_[0]})[0]
(-join($s[$b..($b+$c)]),'')[!$a]

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

PS C:\> .\PangramWindow.ps1 "This isn't a pangram."


PS C:\> .\PangramWindow.ps1 'Everyone knows about that infamous Quick-Brown-Fox (the one who jumped over some lazy ignoramus of a dog so many years ago).'
Quick-Brown-Fox (the one who jumped over some lazy ig

PS C:\> .\PangramWindow.ps1 '"The five boxing wizards jump quickly." stated Johnny, before beginning to recite the alphabet with a bunch of semicolons in the middle. "ABCDEFGHI;;;;;;;;;;;;;;;JKLMNOPQRSTUVWXYZ!" he shouted to the heavens.'
ABCDEFGHI;;;;;;;;;;;;;;;JKLMNOPQRSTUVWXYZ!

मूल का अनगढ़ा विवरण

यह एक ब्रूट-फोर्स नेस्टेड लूप है जो सभी आकारों की स्लाइडिंग विंडो बनाता है:

.SubString(0, 1) -> slide window over the string
.SubString(0, 2) -> slide window over the string
..
.SubString(0, string.Length) -> slide window over the string

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

पैंग्राम वाली सभी विंडो को तीनों अक्षरों में बदल दिया जाता है (अक्षरों सहित संख्याओं की संख्या, डुप्लिकेट , प्रारंभ सूचकांक, विराम चिह्न सहित खिड़की की लंबाई) , जो कि समग्र वर्ण गणना द्वारा सबसे छोटा खोजने के लिए हल किया जाता है, पहले एक को चुना जाता है, और इसके बाद निर्मित आउटपुट स्ट्रिंग ।

स्ट्रिंग की सीमा के बाहर बहुत सारे अनुक्रमण होते हैं, जो अपवादों को फेंकने के बजाय, PowerShell उपयोगी रूप से $ null देता है।

एनबी। नई 156 बाइट एक ही दृष्टिकोण है, लेकिन पाइप लाइन का उपयोग करने के लिए फिर से लिखा गया है।

$string = "$args"

# increasing window widths, outer loop
$allPangramWindows =  foreach ($windowWidth in 1..$string.Length) {

    # sliding windows over string, inner loop
    0..($string.Length - $windowWidth) | ForEach {

        # slice window out of string, returns a char array
        $tmp = $string[$_..($_+$windowWidth)]

        # filter the char array to drop not-letters
        $tmp = $tmp -match '[a-z]'

        # Drop duplicate letters
        $tmpNoDupes = $tmp | sort -Unique

        # If we're left with a 26 character array, this is a pangrammatic window. Output
        # a PowerShell-style tuple of count of letters, start index, width.
        if($tmpNoDupes.Count -eq 26){
            (,@($tmp.Length,$_,$windowWidth))
        }
    }
}

# Force the result into an array (to handle no-results), sort it
# by the first element (num of letters in the window, total)
$allPangramWindows = @( $allPangramWindows | sort -Property {$_[0]} )

# take element 0, a window with the fewest letters
$windowCharCount, $windowStart, $WindowEnd = $allPangramWindows[0]

# uses the results to find the original string with punctuation and whitespace
if ($windowLen) {
    $string[$windowStart..($windowStart + $windowLen)] -join ''
}

एनबी। यह सुनिश्चित नहीं है कि ungolfed संस्करण काम करता है, क्योंकि मैंने यह नहीं लिखा कि तब इसे गोल्फ, यह सिर्फ प्रदर्शनी के लिए है।

— TessellatingHeckler
स्रोत
0

हास्केल, 123 बाइट्स

import Data.Lists
import Data.Char
h x=take 1$sortOn((1<$).filter isAlpha)[e|e<-powerslice x,['a'..'z']\\map toLower e==""]

एक फ़ंक्शन को परिभाषित करता है h, जो खाली सूची नहीं देता है अगर कोई पैंग्रामेटिक खिड़की या न्यूनतम खिड़की के साथ एक तत्व सूची नहीं है। उपयोग उदाहरण:

*Main>  h "'The five boxing wizards jump quickly.' stated Johnny, before beginning to recite the alphabet with a bunch of semicolons in the middle. 'ABCDEFGHI;;;;;;;;;;;;;;;JKLMNOPQRSTUVWXYZ!' he shouted to the heavens."
[". 'ABCDEFGHI;;;;;;;;;;;;;;;JKLMNOPQRSTUVWXYZ"]

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

          [e|e<-powerslice x                  ]  -- for all continuous subsequences
                                                 -- e of the input  
                ,['a'..'z']\\map toLower e==""   -- keep those where the list
                                                 -- difference with all letters is
                                                 -- empty, i.e. every letter appears
                                                 -- at least once
    sortOn((1<$).filter isAlpha)                 -- sort all remaining lists on
                                                 -- their length after removing all
                                                 -- non-letters -> (1<$) see below
take 1                                           -- take the first, i.e. the minimum


calculating the length of a list: we're not interested in the length itself, but
in the relative order of the length. (1<$) replaces each element in a list with
the number 1, e.g. "abc" -> "111", "abcd" -> "1111", etc. Such '1'-strings have
the same order as the length of the original list. One byte saved!
— nimi
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.