pangram เป็นประโยคหรือข้อความที่ตัดตอนมาซึ่งมีตัวอักษรทั้งหมดยี่สิบหกตัวตามที่แสดงในการแข่งขันกอล์ฟรหัสนี้ อย่างไรก็ตามpangrammaticหน้าต่างในรูปแบบของข้อความบางส่วนซึ่งอาจสิ้นสุดหรือเริ่มครึ่งทางผ่านคำซึ่งพบที่ใดที่หนึ่งในงานที่มีขนาดใหญ่กว่า สิ่งเหล่านี้เกิดขึ้นตามธรรมชาติทุกหนทุกแห่งเป็นเซตย่อยที่เหมาะสมของ pangrams จริงดังนั้นเพียงแค่ตรวจสอบว่ามีบางสิ่งที่มีหน้าต่าง pangrammatic จะน่าเบื่อและก็เคยทำมาแล้ว

ดังนั้นเราจึงสนใจที่จะค้นหาข้อความที่เล็กที่สุดที่มีอยู่ในข้อความตามความยาวของตัวอักษร! ในรหัสที่สั้นที่สุดที่เป็นไปได้ไบต์เพื่อให้พอดีกับชุดรูปแบบ

กฎและแนวทาง

• รับสตริงเป็นอินพุตและส่งคืนสตริงของหน้าต่าง pangrammatic ที่เล็กที่สุดในอินพุตหากมีหนึ่งรายการ หากไม่มีให้ส่งคืน Boolean False หรือสตริงว่าง
• ไม่ว่าจะเป็นสตริงเป็นหน้าต่าง pangrammatic หรือไม่เป็นตัวพิมพ์เล็กและตัวใหญ่ขึ้นอยู่กับตัวอักษร 26 ตัวไม่ใช่เครื่องหมายวรรคตอนหรือตัวเลขหรือสัญลักษณ์แปลก ๆ
• ในทำนองเดียวกันความยาวตัวอักษรของหน้าต่าง pangrammatic คือจำนวนทั้งหมดของจำนวนตัวอักษรที่ปรากฏปรากฏในตัวมันเพียงอย่างเดียวและไม่ใช่เพียงจำนวนของตัวละครทุกตัว ค่าที่ส่งคืนต้องน้อยที่สุดตามจำนวนนี้ พวกเราเป็นนักภาษาศาสตร์ไม่ใช่โปรแกรมเมอร์
• อย่างไรก็ตามผลลัพธ์ของหน้าต่าง pangrammatic ต้องเป็นซับสตริงที่แน่นอนของอินพุตที่มีตัวพิมพ์ใหญ่และเครื่องหมายวรรคตอนเดียวกันเป็นต้น
• หากมีหน้าต่าง pangrammatic ที่สั้นที่สุดหลายตัวที่มีความยาวตัวอักษรเดียวกันให้ส่งคืนหนึ่งในนั้น

กรณีทดสอบ

'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'

Pyth, 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(^)

ลองที่นี่!

เมื่อไม่มีวิธีแก้ไขที่ถูกต้องโปรแกรมจะออกโดยมีข้อผิดพลาดโดยไม่มีเอาต์พุตไปยัง stdout

Pyth - 22 ไบต์

\ o / FGITW!

h+ol@GrNZf}GS{rTZ.:z)k

Test Suite

ทับทิม 100 ไบต์

ส่งคืนศูนย์ถ้าไม่พบหน้าต่าง

->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}

JavaScript (ES6), 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 ไบต์ต้องขอบคุณ @Neil!

เว้าแหว่ง

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>

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

ใช่แล้วการจัดการซับสตริง (ไม่มีบิวด์อิน) จึงไม่ใช่ชุดที่แข็งแกร่งของ PowerShell ...

เรารับข้อมูลparam($a)และตั้งค่า hashtable ใหม่ที่ว่างเปล่า$zHashtable นี่จะเป็นที่เก็บของเราของสารตั้งต้น pangrammatic

การใช้การแก้ไขโค้ดของฉันเล็กน้อยจากSubstrings ที่ระเบิดเราสร้างsubstrings ทั้งหมดของอินพุต ใช่แม้สตริงย่อยอย่างเดียวอักขระหนึ่งตัวอักษร นี่คือรหัส - กอล์ฟไม่ใช่รหัสที่เร็วที่สุดเร็วที่สุดรหัส;-)

ทั้งหมดของสตริงเหล่านั้นจะถูกห่อหุ้มใน parens |%{...}และประปาเข้าไปในวงอีกด้วย เราตั้งค่า$yสตริงย่อยปัจจุบันของเราชั่วคราวตั้งตัวนับผู้ช่วย$jและเริ่มการวนซ้ำอีกครั้ง65..90|%{...}อย่างสะดวกผ่านรหัสถ่าน ASCII สำหรับอักษรตัวใหญ่ ภายในวงแต่ละคนเราจะ$yทำให้มันเป็นตัวพิมพ์ใหญ่ทั้งหมดและดึงออก.IndexOfว่าถ่านโดยเฉพาะอย่างยิ่ง ตั้งแต่นี้จะกลับมา-1หากไม่พบเราผลก่อนคูณเข้าไป+1 $jสิ่งนี้ทำให้มั่นใจได้ว่าหากไม่พบตัวละครตัวใดตัวหนึ่ง$jจะเท่ากับศูนย์

ซึ่งเป็นสิ่งที่ifเกี่ยวกับ หาก$jไม่ใช่ศูนย์นั่นหมายความว่าพบจดหมายทุกฉบับอย่างน้อยหนึ่งครั้งในซับสตริง$yดังนั้นเราจึงต้องเพิ่มลงในกลุ่มผู้สมัครของเรา เราทำได้โดยการใช้$yและ-replaceไอเอ็นจีทุกตัวอักษรที่ไม่มีอะไรที่เราได้รับตัวอักษรที่มีความยาวของสตริงย่อยที่ เราใช้สิ่งนั้นเป็นดัชนีลงใน hashtable $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

Haskell, 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]

น้อย golfed:

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

แปลกใจประหลาดใจ: มันช้าจริงๆ

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;

ยกเลิกแข็งแรงเล่นกอล์ฟ

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 ตำแหน่งของอักขระตัวแรกของสตริงย่อย
l ตำแหน่งของอักขระตัวสุดท้ายที่เพิ่มไปยังสตริงย่อยปัจจุบัน

cมุมมองผลตอบแทนอักษรหนึ่งตัวอักษรในเวลา

aมุมมองผลตอบแทนที่ตัวอักษรต่อกันเป็นสายเดียว

SELECT s,f,SUM(SIGN(INSTR(LOWER(s),c))
ส่งคืนซับสตริงแต่ละจำนวนจำนวนตัวอักษรที่แตกต่างกันที่มีอยู่ในมัน
INSTRส่งกลับ pos ของตัวอักษรในสตริงย่อย, 0 ถ้าไม่ได้อยู่
SIGNส่งคืน 1 ถ้า pos> 0, 0 ถ้า pos = 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))
เก็บสตริงย่อยเท่านั้นที่มีจำนวนตัวอักษรที่เล็กกว่า
หากมีมากกว่าหนึ่งจะถูกเก็บไว้ครั้งแรกเรียงเป็นสตริงขึ้น

Python 3, 171, 167, 163, 157 , 149 bytes

บันทึก 4 ไบต์ด้วย DSM
บันทึก 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.')

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

สำหรับแต่ละหน้าต่างจะกรองเฉพาะตัวอักษร (การจับคู่ regex ที่ไม่คำนึงถึงขนาดตัวพิมพ์โดยค่าเริ่มต้น) เรียกใช้อักขระที่เหลือผ่านตัวกรองที่ไม่ซ้ำกันตรวจสอบว่ามีอักขระที่ไม่ซ้ำกัน 26 รายการเป็นการทดสอบ pangram

หน้าต่างทั้งหมดที่มี pangrams จะถูกเปลี่ยนเป็นสามส่วนของ(จำนวนตัวอักษรรวมถึง dupes, ดัชนีเริ่มต้น, ความยาวของหน้าต่างรวมถึงเครื่องหมายวรรคตอน) , ซึ่งเรียงลำดับเพื่อค้นหาที่สั้นที่สุดโดยการนับจำนวนตัวอักษรโดยรวม .

มีการจัดทำดัชนีจำนวนมากนอกขอบเขตของสตริงซึ่ง PowerShell ส่งคืนประโยชน์เป็น $ null สำหรับแทนที่จะใช้การยกเว้นข้อยกเว้น

NB ใหม่ 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 ''
}

NB ไม่แน่ใจว่าเวอร์ชั่น ungolfed ทำงานได้หรือไม่เพราะฉันไม่ได้เขียนมันแล้วก็ตีกอล์ฟมันเป็นเพียงแค่การแสดงออกเท่านั้น

Haskell, 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ซึ่งจะส่งกลับรายการที่ว่างเปล่าหากไม่มีหน้าต่าง pangrammatic หรือรายการองค์ประกอบหนึ่งที่มีหน้าต่างขั้นต่ำ ตัวอย่างการใช้งาน:

*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!