एक शब्द सूची से सबसे कम pangrams का पता लगाएं

Question

एक pangram एक स्ट्रिंग है कि हर पत्र शामिल है a- zअंग्रेजी वर्णमाला, केस-संवेदी की। (यह ठीक है कि यदि पैंग्राम में एक पत्र की एक से अधिक प्रतिलिपि शामिल है, या यदि इसमें अक्षरों के अलावा गैर-अक्षर वर्ण हैं।)

एक प्रोग्राम या फ़ंक्शन लिखें जिसका इनपुट स्ट्रिंग्स की एक सूची है, और जो एक या एक से अधिक स्ट्रिंग्स को आउटपुट करता है जिसमें निम्नलिखित गुण हैं:

• प्रत्येक आउटपुट स्ट्रिंग एक पैंग्राम होना चाहिए।
• प्रत्येक आउटपुट स्ट्रिंग को इनपुट लिस्ट से रिक्त स्थान द्वारा अलग किए गए एक या अधिक स्ट्रिंग्स को समतल करके बनाया जाना चाहिए।
• इन गुणों के साथ सभी स्ट्रिंग्स के बीच प्रत्येक आउटपुट स्ट्रिंग को सबसे छोटा या सबसे छोटा होना चाहिए।

कई कार्यक्रम केवल एक स्ट्रिंग आउटपुट के लिए चुनेंगे; यदि आप अन्यथा आउटपुट को सीमित करने के लिए अतिरिक्त कोड लिखना चाहते हैं, तो आप केवल एक से अधिक स्ट्रिंग आउटपुट करना चाहते हैं।

आप यह मान सकते हैं कि इनपुट में कोई अप्रमाणित वर्ण या रिक्त स्थान नहीं है, और इसमें कोई भी शब्द (सूची की लंबाई के प्राकृतिक लघुगणक से 26 गुना) वर्णों से अधिक नहीं है। (आप यह नहीं मान सकते हैं कि इनपुट में अक्षरों के अलावा कुछ नहीं है, या केवल लोअरकेस अक्षर हैं; विराम चिह्न और बड़े अक्षर पूरी तरह से संभव हैं।)

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

abcdefghi
defghijkl
ijklmnop
lmnopqrs
opqrstuvw
rstuvwxyz

आपको अपने सबमिशन के साथ अपने प्रोग्राम के आउटपुट का एक नमूना शामिल करना चाहिए। (यह अलग-अलग लोगों के लिए अलग-अलग शब्द सूचियों के उपयोग के परिणामस्वरूप भिन्न हो सकता है।)

विजय की स्थिति

यह एक प्रतिबंधित-जटिलता कोड-गोल्फ चुनौती है। विजेता सबसे छोटा कार्यक्रम है (बाइट्स में) जो बहुपद समय में चलता है । (उन लोगों के लिए एक सारांश जो यह नहीं जानते कि इसका क्या अर्थ है: यदि आप शब्द सूची के आकार को दोगुना करते हैं, तो प्रोग्राम को स्थिर कारक से अधिक नहीं होना चाहिए। हालांकि, प्रश्न में निरंतर कारक आपके जितना बड़ा हो सकता है। उदाहरण के लिए, यह इसके लिए वैध है कि यह चार गुना धीमा हो जाए, या आठ गुना धीमा हो जाए, लेकिन शब्द सूची की लंबाई के एक कारक से छोटा होने के लिए नहीं, जिसके माध्यम से यह धीमा हो जाता है, वह बाध्य होना चाहिए।)

Comments

जटिलता का निर्धारण करते समय, क्या हम इस तथ्य का उपयोग कर सकते हैं कि प्रत्येक शब्द अधिकतम 26 अक्षरों पर है? वर्णमाला का आकार 26 का एक स्थिर है?

— xnor

हाँ। मैंने उस इनपुट पर प्रतिबंध को आंशिक रूप से परिभाषित करने / परिभाषित करने की जटिलता को आसान बनाने के लिए रखा।

मुझे लगता है कि यह एक तकनीकीता में चलता है। यदि आप बार-बार इनपुट शब्दों को अनदेखा करते हैं, तो अधिकांश 27 ^ 26 संभव इनपुट शब्द हैं, और इसलिए अधिकांश 2 ^ (27 ^ 26) संभव इनपुट के रूप में संभव सबसेट हैं। यह बहुत बड़ा है लेकिन स्थिर है। इसलिए, इस परिमित सेट पर कोई भी कार्यक्रम निरंतर-समय पर होता है, जिसमें निरंतर सभी संभावित आदानों पर उठाए गए कदमों की अधिकतम संख्या होती है।

— 19

मैंने यह नहीं कहा कि इनपुट में कोई डुप्लिकेट शब्द नहीं हैं। मुझे लगता है कि आप एक "तकनीकी" O (n) समय में विराम चिह्नों को हटाकर और पहले इनपुट को काटकर कार्यक्रम चला सकते हैं, हालाँकि (या अधिक संभावना है O (n log n), जो किसी मूलांक से बहुत कम मेमोरी का उपयोग करेगा समर्पण होगा)। फिर आपको फ़िल्टर किए गए संस्करण से मूल शब्द सूची पर वापस जाना होगा। जब तक आप वास्तव में उन सभी चरणों से गुजरते हैं, तब तक आप बहुपद समय पर सवाल नहीं उठा सकते।

मैं गैर-पत्रों के बारे में भूल गया था। क्या हम मान सकते हैं कि ये ASCII हैं, या अन्यथा कुछ परिमित सेट के भीतर हैं? यदि ऐसा है, तो मुझे लगता है कि कोई भी एल्गोरिथ्म जो डुप्लिकेटिंग से शुरू होता है, बहुपद-समय होने का दावा कर सकता है।

— 20

Answer 1

रूबी 159 (पुनरावृत्त)

माणिक 227 220 229 227 221 (पुनरावर्ती)

नया पुनरावृत्त समाधान (@Niel द्वारा वर्णित एल्गोरिदम पर आधारित):

c={('A'..'Z').to_a=>""}
while l=gets
d=c.clone
c.map{|k,v|j=k-l.upcase.chars
w=v+" "+l.strip
d[j]=w if !c[j]||c[j].size<w.size}
c=d
end
x=c[[]]
p x[1..-1] if x

पुराना पुनरावर्ती समाधान:

W=[]
while l=gets
W<<l.strip
end
I=W.join(" ")+"!!"
C={[]=>""}
def o(r)if C[r]
C[r]
else
b=I
W.map{|x|s=r-x.upcase.chars
if s!=r
c=x+" "+o(s)
b=c if c.size<b.size
end}
C[r]=b
end
end
r=o ('A'..'Z').to_a
p r[0..-2] if r!=I

बाइट माप फ़ाइल में अंतिम न्यूलाइन को छोड़ने पर आधारित है, जो इससे कोई फर्क नहीं पड़ता ruby 2.3.1p112। एक छोटा सा बग (जोड़कर) को ठीक करने के बाद बाइट की गिनती वापस आ गई.downcase .upcase समस्या बयान के अनुसार केस-असंवेदनशीलता के लिए)।

यहाँ पहचानकर्ताओं को छोटा करने से पहले का एक संस्करण है और इस तरह:

#!/usr/bin/env ruby

$words = [];

while (line=gets)
  $words << line[0..-2];
end

$impossible = $words.join(" ")+"!!";

$cache = {};

def optimize(remaining)
  return $cache[remaining] if ($cache[remaining]);
  return "" if (remaining == []);

  best = $impossible;

  $words.each{|word|
    remaining2 = remaining - word.chars;
    if (remaining2 != remaining)
      curr = word + " " + optimize(remaining2);
      best = curr if (curr.length < best.length);
    end
  };

  $stderr.puts("optimize(#{remaining.inspect})=#{best.inspect}");

  return $cache[remaining] = best;
end

result = optimize(('a'..'z').to_a);

puts(result[0..-1]);

यह कैसे काम करता है? यह मूल रूप से कवर करने के लिए अभी भी वर्णों के एक सेट को बनाए रखता है और केवल एक शब्द पर पुनरावृत्ति करता है यदि यह खुला सेट को कम करेगा। इसके अतिरिक्त, पुनरावृत्ति के परिणाम याद हैं। 2 ^ 26 का प्रत्येक उपसमूह एक ज्ञापन तालिका प्रविष्टि से मेल खाता है। प्रत्येक ऐसी प्रविष्टि की गणना इनपुट फ़ाइल के आकार के अनुपात में की जाती है। तो पूरी बात यह है O(N)( Nइनपुट फ़ाइल का आकार कहां है), एक विशाल निरंतर के साथ।

Answer 2

जावास्क्रिप्ट (ईएस 6), 249 248 बाइट, संभवतः प्रतिस्पर्धा

a=>a.map(w=>w.replace(/[a-z]/gi,c=>b|=1<<parseInt(c,36)-9,b=0,l=w.length)&&(m.get(b)||[])[0]<l||m.set(b,[l,w]),m=new Map)&&[...m].map(([b,[l,w]])=>m.forEach(([t,s],e)=>(m.get(e|=b)||[])[0]<=t+l||m.set(e,[t+l+1,s+' '+w])))&&(m.get(-2^-1<<27)||[])[1]

स्पष्टीकरण: अक्षरों को एक बिटमास्क में परिवर्तित करके सरणी को बदल देता है, जिससे नक्शे में प्रत्येक बिटमास्क के लिए केवल सबसे छोटा शब्द बच जाता है। फिर नक्शे की एक प्रति पर पुनरावृत्ति, परिणामी स्ट्रिंग छोटा होगा अगर प्रत्येक संयुक्त bitmask जोड़कर नक्शे में वृद्धि। अंत में पैंग्राम के अनुरूप बिटमैप के लिए सहेजे गए स्ट्रिंग को वापस करें। ( undefinedयदि कोई स्ट्रिंग मौजूद नहीं है तो वापस लौटाता है।)

Comments

दिलचस्प। क्या आप इस पर और अधिक विस्तार कर सकते हैं कि यह कैसे काम करता है और, यदि उपलब्ध हो, तो असंगठित कोड पोस्ट करें?

— डिप्रेस्ड

यह एक मान्य / प्रतिस्पर्धी प्रविष्टि होनी चाहिए। मुझे लगता है कि यह वास्तव में ओ ( एन लॉग एन ) में चलता है , वास्तव में! (नक्शे में 2²⁶ प्रविष्टियों की एक कठिन सीमा है, और इस तरह जटिलता में दिखाई नहीं देता है; इस प्रकार केवल समय बिताने का समय इनपुट पढ़ने में है।)

मैं सिर्फ विवरण को फिर से पढ़ता हूं और मुझे लगता है कि यह अब कैसे काम करता है। साफ। +1 ... हम्म, यह हालांकि जोड़े पर विचार करके नक्शे को बढ़ाने की कोशिश को रोकने का फैसला कब करता है? यह तब तक चलता रहना चाहिए जब तक कोई आराम संभव न हो।

— डिप्रेस्ड

@DepressedDaniel मूल शब्द सूची से निकाले गए प्रत्येक बिटमास्क के लिए, यह अब तक पाए गए सभी आंशिक pangrams की जाँच करता है, और शब्द जोड़ने पर एक पैंग्राम बनाता है जो उस समय के छोटे से एक है जो संयुक्त रूप सेmmask के लिए जानता है।

— नील

@ ais523 बड़े इनपुट (> 1000 शब्द) के लिए, अधिकांश समय स्वैपिंग में लगता है। मैंने एक मानचित्र से एक ऐरे में स्विच करने की कोशिश की और यह धीमा हो गया!

— नील

Answer 3

पायथन 3, 98 , 94 , 92 बाइट्स

print([s for s in input().split()if sum([1 for c in range(65,91)if chr(c)in s.upper()])>25])

अक्षर के ASCII प्रतिनिधित्व के माध्यम से Iterates और यदि स्ट्रिंग में अक्षर पाया जाता है, तो एक सूची में 1 जोड़ देता है। यदि सूची का योग 25 से अधिक है, तो इसमें वर्णमाला के सभी अक्षर हैं और मुद्रित किया जाएगा।

Comments

मुझे लगता है कि आप (' ')और के बीच की जगह निकाल सकते हैं if। तुम भी बदल सकते हैं ord(i) in range(65,91)करने के लिए 91>x>=65। इसके अलावा, जटिलता क्या है?

— NoOneIsHere

इस समाधान की जटिलता क्या है? इसका उत्तर बहुपद जटिलता में होना आवश्यक है, अन्यथा यह गैर-प्रतिस्पर्धात्मक है।

— NoOneIsHere 21

क्षमा करें, मुझे लगता है कि यह O (n) है, क्योंकि इनपुट सूची लंबाई में भिन्न हो सकती है लेकिन

— Erich

क्षमा करें, मुझे लगता है कि यह O (n) है, क्योंकि इनपुट सूची लंबाई में भिन्न हो सकती है, लेकिन दूसरा लूप हमेशा 65 से 90 तक जाता है। लेकिन मैंने इसका परीक्षण नहीं किया है।

— एरच

यह सुनिश्चित नहीं करता है कि "इन गुणों के साथ सभी स्ट्रिंग्स के बीच प्रत्येक आउटपुट स्ट्रिंग को सबसे छोटा होना चाहिए, या सबसे छोटा होना चाहिए।"

— डिप्रेस्डडैनियल