तार अद्वितीय रखते हुए पत्र निकालें

Question

इस अद्भुत (विचारों और वोटों की संख्या के आधार पर) चुनौती से प्रेरित होकर , जो, मेरे विनम्र राय में, बहुत कम जवाब हैं।

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

उदाहरण:

"दिन" और "दिन" दिया; "ay" लौटाएं, क्योंकि दिए गए तार "D" और "d" होंगे जब वर्ण "ay" हटाए जाएंगे।

"हैलो वर्ल्ड!", "हैलो वर्ल्ड" और "हैलो वर्ल्ड" को देखते हुए; रिटर्न "हेलो वर्ड" देता है क्योंकि स्ट्रिंग्स "!", "डब्ल्यू", और "डब्ल्यू" होंगे जब वर्ण "हेलो वर्ड" (एक स्थान के साथ) हटा दिए जाते हैं।

"शताब्दी", "दशक", "वर्ष", "महीना", "सप्ताह", "दिन", "घंटा", "मिनट", और "दूसरा" दिया; "सेंटुरैडॉवी" लौटें क्योंकि दिए गए शब्द "y", "a", "ya", "mh", "k", "ay", "h", "m", "s" होंगे जब वर्ण "centurur" " हटा दिए गए हैं।

लौटे सेट का क्रम और प्रारूप महत्वपूर्ण नहीं है।

Comments

आपका दूसरा मामला गलत है: "हेलो राइट" कुल 4 लंबाई देता है "!", "डब्ल्यू।" और"।

— ल्यूक

@ ल्यूक धन्यवाद। मैं ठीक कर दूँगा। यह दर्शाता है कि हमें एक एल्गोरिथ्म की आवश्यकता है, क्योंकि इसे हाथ से करना त्रुटि प्रवण है।

— आदाम

और तीसरे के लिए, 'सेंटुरूवी' 'पैदावार' y ',' a ',' ya ',' mh ',' k ',' ay ',' h ',' m ',' s 'की कुल लंबाई 12.

— लूका

@ ल्यूक धन्यवाद।

— 20

किसी अन्य चुनौती में आपकी सहायता करने के लिए एक चुनौती का उपयोग करने के लिए +1!

— ल्यूक

Answer 1

हास्केल, 138 130 बाइट्स

import Data.List
c=concat
f i=snd$minimum[(length$c q,s)|s<-subsequences$nub$c i,q<-[map(filter(`notElem`s))i],nub q==q,all(>"")q]

उपयोग उदाहरण: f ["century", "decade", "year", "month", "week", "day", "hour", "minute", "second"] -> "centurdoki"।

यह एक क्रूर बल दृष्टिकोण है।

     s<-subsequences$nub$c i  -- concatenate input i to a single string, remove
                              -- duplicates and make a list of all subsequences
       q<-[map(filter(...))i] -- remove chars appearing in subsequence s from all
                              -- input words, call result q
          nub q==q            -- keep those s where q has no duplicates (i.e. each
                              -- resulting string is unique) and
            all(>"")q         -- contains no empty strings
  (length$c q,s)              -- make pairs from all kept s, where the first element
                              -- is the combines length of all strings in q,
                              -- second element is s itself
snd$minimum                   -- find minimum of those pairs and discard length

संपादित करें: @Seeq ने मुझे 8 बाइट बचाने में मदद की। धन्यवाद!

Comments

कैसे के बारे में map(#s), इसलिए आपको फ्लिप करने की आवश्यकता नहीं है notElem? संपादित करें: या आप इसे सिर्फ इनलाइन नहीं कर सकते?

— seequ

@Seeq: जब कॉल के माध्यम से map(#s), (#)के रूप में परिभाषित किया जाना चाहिए flip (filter . flip notElem)। लेकिन निश्चित रूप से इनलाइनिंग बहुत कम है। धन्यवाद!

— निम्मी

Answer 2

अजगर, ३४

प्रारूप में इनपुट लेता है ["century", "decade", "year", "month", "week", "day", "hour", "minute", "second"]। गोल्फ टिप्स की सराहना की जाती है, हमेशा की तरह।

hh.mlsebfqlQl{eTf!}keTm,dm-kdQy{sQ

Answer 3

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

hols-RNQf<}kJ-RTQ{IJy{sQ

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

ध्यान दें कि अंतिम परीक्षण का मामला चलने में थोड़ा समय लगेगा।

सरणी रूप में इनपुट लेता है, जैसे ["Day", "day"] ।

एक और दिलचस्प जो मुझे मिला और इसहाक में सुधार हुआ (24 बाइट्स भी):

-J{sQhlDsM.A#f{ITm-RdQyJ

Comments

मैं दूसरे दृष्टिकोण को 24 बाइट्स तक कम करने में सक्षम था: -J{sQhlDsM.A#f{ITm-RdQyJ यहाँ

— isaacg