Wordiest संयोजन लॉक का पता लगाएं


18

मेरे पास एक संयोजन पैडलॉक है जिसमें संख्याओं के बजाय पत्र हैं। यह इस तरह दिखता है: http://pictures.picpedia.com/2012/09/Word_Combination_Padlock.jpg 5 रीलों हैं, जिनमें से प्रत्येक पर 10 अलग-अलग अक्षर हैं।

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

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

ABCDEFGHIJ DEFGHIJKLM ZYXWVUTSR ABCDEFGHIJ ABCDEFGHIJ

(यदि आप बहुत कल्पनाशील नहीं थे, तो यह है)।

स्थिरता के लिए, कृपया http://www.cs.duke.edu/~ola/ap/linuxwords पर शब्द सूची का उपयोग करें

उस सूची में कोई भी 5 अक्षर का शब्द ठीक है, जिसमें उचित नाम शामिल हैं। चीन और लिव को नजरअंदाज करें और सूची में किसी भी अन्य शब्द को शामिल करें जिसमें एक गैर अज़ चरित्र हो।

जीतने वाला कार्यक्रम वह है जो शब्दों का सबसे बड़ा सेट तैयार करता है। इस घटना में कि कई कार्यक्रम समान परिणाम प्राप्त करते हैं, पहला पोस्ट किया जाता है जीतता है। कार्यक्रम 5 मिनट से कम समय में चलना चाहिए।

संपादित करें: चूंकि गतिविधि कम हो गई है, और कोई बेहतर समाधान नहीं निकला है, मैं पीटर टेलर को विजेता घोषित करता हूं! आपके आविष्कारशील समाधान के लिए सभी का धन्यवाद।


कोई यह सोचकर उचित नाम कैसे गिन सकता है कि वे संस्कृतियों में इतने भिन्न हैं?
एलसर

@ सालसार, अगर मैं सही ढंग से समझूं, तो सूची में कोई भी शब्द ठीक है, भले ही वह एक उचित नाम हो (किसी भी संस्कृति में)।
बदसूरत

ओह ठीक है, वहाँ , में नहीं देखा कि
elssar

तो, एक कोड सवाल नहीं; लेकिन तर्क?
ब्रिगैंड

2
इसे कोड-चुनौती के रूप में चिह्नित किया गया है : चुनौती क्या है? आपके द्वारा मांगे गए सभी मूल्य हैं जो एक फ़ंक्शन को अधिकतम करता है जिसके डोमेन का आकार लगभग 110.3 बिट्स है। इसलिए यह समस्या को हल करने के लिए संभव नहीं है, लेकिन इसका सटीक उत्तर प्राप्त करना संभव है, और शायद इसे सही साबित करने के लिए भी। सभी को ध्यान में रखते हुए, एक उत्तर पर विचार करने के लिए आवश्यक शर्तें क्या हैं, और एक विजेता का चयन करने के लिए आप किन मानदंडों का उपयोग करने जा रहे हैं?
पीटर टेलर

जवाबों:


6

सरल लालची पहाड़ी-चढ़ाई से 1275 शब्द

कोड # है। उत्पादित समाधान है

Score 1275 from ^[bcdfgmpstw][aehiloprtu][aeilnorstu][acdeklnrst][adehklrsty]$

मैं उस आउटपुट स्वरूप का उपयोग कर रहा हूं क्योंकि यह वास्तव में परीक्षण करना आसान है:

grep -iE "^[bcdfgmpstw][aehiloprtu][aeilnorstu][acdeklnrst][adehklrsty]$" linuxwords.txt | wc

namespace Sandbox {
    class Launcher {
        public static void Main(string[] args)
        {
            string[] lines = _Read5s();
            int[][] asMasks = lines.Select(line => line.ToCharArray().Select(ch => 1 << (ch - 'a')).ToArray()).ToArray();
            Console.WriteLine(string.Format("{0} words found", lines.Length));

            // Don't even bother starting with a good mapping.
            int[] combos = _AllCombinations().ToArray();
            int[] best = new int[]{0x3ff, 0x3ff, 0x3ff, 0x3ff, 0x3ff};
            int bestSc = 0;
            while (true)
            {
                Console.WriteLine(string.Format("Score {0} from {1}", bestSc, _DialsToString(best)));

                int[] prevBest = best;
                int prevBestSc = bestSc;

                // Greedy hill-climbing approach
                for (int off = 0; off < 5; off++)
                {
                    int[] dials = (int[])prevBest.Clone();

                    dials[off] = (1 << 26) - 1;
                    int[][] filtered = asMasks.Where(mask => _Permitted(dials, mask)).ToArray();
                    int sc;
                    dials[off] = _TopTen(filtered, off, out sc);
                    if (sc > bestSc)
                    {
                        best = (int[])dials.Clone();
                        bestSc = sc;
                    }
                }

                if (bestSc == prevBestSc) break;
            }

            Console.WriteLine("Done");
            Console.ReadKey();
        }

        private static int _TopTen(int[][] masks, int off, out int sc)
        {
            IDictionary<int, int> scores = new Dictionary<int, int>();
            for (int k = 0; k < 26; k++) scores[1 << k] = 0;

            foreach (int[] mask in masks) scores[mask[off]]++;

            int rv = 0;
            sc = 0;
            foreach (KeyValuePair<int, int> kvp in scores.OrderByDescending(kvp => kvp.Value).Take(10))
            {
                rv |= kvp.Key;
                sc += kvp.Value;
            }
            return rv;
        }

        private static string _DialsToString(int[] dials)
        {
            StringBuilder sb = new StringBuilder("^");
            foreach (int dial in dials)
            {
                sb.Append('[');
                for (int i = 0; i < 26; i++)
                {
                    if ((dial & (1 << i)) != 0) sb.Append((char)('a' + i));
                }
                sb.Append(']');
            }
            sb.Append('$');
            return sb.ToString();
        }

        private static IEnumerable<int> _AllCombinations()
        {
            // \binom{26}{10}
            int set = (1 << 10) - 1;
            int limit = (1 << 26);
            while (set < limit)
            {
                yield return set;

                // Gosper's hack:
                int c = set & -set;
                int r = set + c;
                set = (((r ^ set) >> 2) / c) | r;
            }
        }

        private static bool _Permitted(int[] dials, int[] mask)
        {
            for (int i = 0; i < dials.Length; i++)
            {
                if ((dials[i] & mask[i]) == 0) return false;
            }
            return true;
        }

        private static string[] _Read5s()
        {
            System.Text.RegularExpressions.Regex word5 = new System.Text.RegularExpressions.Regex("^[a-z][a-z][a-z][a-z][a-z]$", System.Text.RegularExpressions.RegexOptions.Compiled);
            return File.ReadAllLines(@"d:\tmp\linuxwords.txt").Select(line => line.ToLowerInvariant()).Where(line => word5.IsMatch(line)).ToArray();
        }
    }
}

मैं इस सटीक समाधान के साथ अपने उत्तर को संपादित करने वाला था, लेकिन आपने मुझे इसे हरा दिया।
कार्डबोर्ड_बॉक्स

जब मैं 1000 यादृच्छिक प्रारंभिक संयोजनों से एक ही पहाड़ी पर चढ़ने वाली खोज को चलाता हूं और पाया गया 1000 स्थानीय ऑप्टिमा का सबसे अच्छा चयन करता हूं, तो यह हमेशा एक ही समाधान का उत्पादन करता है, इसलिए यह वैश्विक इष्टतम होने की संभावना है।
पीटर टेलर

यह आपकी संभावना की परिभाषा पर निर्भर करता है;; लेकिन अन्य दृष्टिकोणों से यह "पुष्टि" है जो अधिकतम 1275 के रूप में प्राप्त होता है। (और क्वांटम-टिक-टैक-टो कहाँ चला गया?)
हावर्ड

@ हॉवर्ड, यह सिर्फ एक प्रोजेक्ट में कई एंट्री पॉइंट्स को सपोर्ट न करने वाली .Net की एक कलाकृति थी। मेरे पास एक "सैंडबॉक्स" परियोजना है जो मैं इस तरह से सामान के लिए उपयोग करता हूं, और मैं आमतौर पर Mainविभिन्न _Mainतरीकों को कॉल करने के लिए विधि बदल देता हूं ।
पीटर टेलर

मैंने एक आनुवंशिक एल्गोरिथ्म की कोशिश की और कुछ ही मिनटों में एक ही परिणाम मिला, और फिर अगले घंटे में कुछ भी नहीं हुआ, इसलिए मुझे आश्चर्य नहीं होगा अगर यह इष्टतम है।
कार्डबोर्ड_बॉक्स

4

पायथन (3), 1273 on 30.5%

यह वास्तव में भोली दृष्टिकोण है: प्रत्येक स्थिति में प्रत्येक अक्षर की आवृत्ति का एक तालमेल रखें, फिर "सबसे खराब" पत्र को समाप्त करें जब तक कि शेष अक्षर रीलों पर फिट नहीं होंगे। मुझे आश्चर्य है कि यह इतना अच्छा लगता है।

सबसे दिलचस्प बात यह है कि मेरे पास सी # 1275 समाधान के समान ही लगभग एक ही आउटपुट है, इसके अलावा मेरे पास Nअपनी आखिरी रील पर है A। यह Aमेरी 11 वीं-से-अंतिम समाप्ति थी, वह भी, ए Vऔर ए फेंकने से पहले G

from collections import Counter

def main(fn, num_reels, letters_per_reel):
    # Read ye words
    words = []
    with open(fn) as f:
        for line in f:
            word = line.strip().upper()
            if len(word) == num_reels and word.isalpha():
                words.append(word)

    word_pool_size = len(words)

    # Populate a structure of freq[reel_number][letter] -> count
    freq = [Counter() for _ in range(num_reels)]
    for word in words:
        for r, letter in enumerate(word):
            freq[r][letter] += 1

    while True:
        worst_reelidx = None
        worst_letter = None
        worst_count = len(words)
        for r, reel in enumerate(freq):
            # Skip reels that already have too-few letters left
            if len(reel) <= letters_per_reel:
                continue

            for letter, count in reel.items():
                if count < worst_count:
                    worst_reelidx = r
                    worst_letter = letter
                    worst_count = count

        if worst_letter is None:
            # All the reels are done
            break

        # Discard any words containing this worst letter, and update counters
        # accordingly
        filtered_words = []
        for word in words:
            if word[worst_reelidx] == worst_letter:
                for r, letter in enumerate(word):
                    freq[r][letter] -= 1
                    if freq[r][letter] == 0:
                        del freq[r][letter]
            else:
                filtered_words.append(word)
        words = filtered_words

    for reel in freq:
        print(''.join(sorted(reel)))

    print("{} words found (~{:.1f}%)".format(
        len(words), len(words) / word_pool_size * 100))

पैदा करता है:

BCDFGMPSTW
AEHILOPRTU
AEILNORSTU
ACDEKLNRST
DEHKLNRSTY
1273 words found (~30.5%)

प्रतिशत क्या दर्शाता है?
जो जेड।

दिए गए शब्दों का प्रतिशत जो रीलों के प्रस्तावित सेट के साथ बनाया जा सकता है
ईवे

ठीक है। (हू, मैंने अभी देखा कि आप कौन थे।)
जो जेड।

हा, छोटी सी दुनिया।
ईवे

3

गणितज्ञ , 1275 शब्द बार-बार ...

यह कोड नहीं है क्योंकि यह प्रश्न उस कॉल के लिए प्रकट नहीं होता है।

wordlist = Flatten @ Import @ "http://www.cs.duke.edu/~ola/ap/linuxwords";
shortlist = Select[ToLowerCase@wordlist, StringMatchQ[#, Repeated[LetterCharacter, {5}]] &];
string = "" <> Riffle[shortlist, ","];

set = "a" ~CharacterRange~ "z";
gb = RandomChoice[set, {5, 10}];

best = 0;
While[True,
  pos = Sequence @@ RandomInteger /@ {{1, 5}, {1, 10}};
  old = gb[[pos]];
  gb[[pos]] = RandomChoice @ set;
  If[best < #,
    best = #; Print[#, "   ", StringJoin /@ gb],
    gb[[pos]] = old
  ] & @ StringCount[string, StringExpression @@ Alternatives @@@ gb]
]

शब्द की गिनती जल्दी (10 सेकंड से कम) ज्यादातर रन पर 1275 तक होती है, लेकिन इससे आगे कभी नहीं निकलती है। मैंने एक सैद्धांतिक स्थानीय अधिकतम से बाहर निकलने के प्रयास में एक समय में एक से अधिक अक्षरों को उलटने की कोशिश की, लेकिन इससे कभी मदद नहीं मिली। मुझे दृढ़ता से संदेह है कि 1275 दी गई शब्द सूची की सीमा है। यहाँ एक पूर्ण रन है:

36   {tphcehmqkt,agvkqxtnpy,nkehuaakri,nsibxpctio,iafwdyhone}

37   {tpicehmqkt,agvkqxtnpy,nkehuaakri,nsibxpctio,iafwdyhone}

40   {tpicehmqkt,agvkqxtnpy,nkehuaakri,nsibxpctio,iafldyhone}

42   {tpicehmqkt,agvkqxtnpy,nkehuaakri,nsfbxpctio,iafldyhone}

45   {tpicehmrkt,agvkqxtnpy,nkehuaakri,nsfbxpctio,iafldyhone}

48   {tpicehmrkt,agvkwxtnpy,nkehuaakri,nsfbxpctio,iafldyhone}

79   {tpicehmskt,agvkwxtnpy,nkehuaakri,nsfbxpctio,iafldyhone}

86   {tpicehmskt,agvkwxtnpy,nkehuaakri,esfbxpctio,iafldyhone}

96   {tpicehmskt,agvkwxtnpy,nkehuaokri,esfbxpctio,iafldyhone}

97   {tpicehmskt,agvkwxtnpy,nkehuaokri,esfbxpctio,ipfldyhone}

98   {tpicehmskv,agvkwxtnpy,nkehuaokri,esfbxpctio,ipfldyhone}

99   {tpicehmskv,agvkwxtnpy,nkehuaokri,esfbzpctio,ipfldyhone}

101   {tpicehmskv,agvkwxtnpy,nkehuaokri,esfhzpctio,ipfldyhone}

102   {tpicehmskv,agvkwxtnpy,nkehuaokri,esfhzpctno,ipfldyhone}

105   {tpicehmskv,agvkwxtnpy,nkehuaokri,esfhzmctno,ipfldyhone}

107   {tpicehmskn,agvkwxtnpy,nkehuaokri,esfhzmctno,ipfldyhone}

109   {tpgcehmskn,agvkwxtnpy,nkehuaokri,esfhzmctno,ipfldyhone}

115   {tpgcehmsan,agvkwxtnpy,nkehuaokri,esfhzmctno,ipfldyhone}

130   {tpgcehmsan,agvkwxtnpy,nkehuaokri,esfhzmctno,ipfldyhons}

138   {tpgcehmsan,agvkwxtnpy,nkehuaokri,esfhzmctno,ipfldytons}

143   {tpgcehmsab,agvkwxtnpy,nkehuaokri,esfhzmctno,ipfldytons}

163   {tpgcehmsab,auvkwxtnpy,nkehuaokri,esfhzmctno,ipfldytons}

169   {tpgcehmsab,auvkwctnpy,nkehuaokri,esfhzmctno,ipfldytons}

176   {tpgcehmsab,auvkwctnpy,nkehuaokri,esfhzmctno,ihfldytons}

189   {tpgcehmsab,auvkwchnpy,nkehuaokri,esfhzmctno,ihfldytons}

216   {tpgcehmsab,auvkwchnpy,nkehtaokri,esfhzmctno,ihfldytons}

220   {tpgcehmsab,auvkwthnpy,nkehtaokri,esfhzmctno,ihfldytons}

223   {tpgcehmsab,auvkwthnpy,nkehtaokri,esfhbmctno,ihfldytons}

234   {tpgcehmsab,auvkwthnpy,nkegtaokri,esfhbmctno,ihfldytons}

283   {tpgcehmsab,auvkwthnpy,nkegtaokri,esfhbrctno,ihfldytons}

285   {tpdcehmsab,auvkwthnpy,nkegtaokri,esfhbrctno,ihfldytons}

313   {tpdcehmsab,auvkwthnly,nkegtaokri,esfhbrctno,ihfldytons}

371   {tpdcehmsab,auvkethnly,nkegtaokri,esfhbrctno,ihfldytons}

446   {tpdcehmsab,auvoethnly,nkegtaokri,esfhbrctno,ihfldytons}

451   {tpdcehmslb,auvoethnly,nkegtaokri,esfhbrctno,ihfldytons}

465   {tpdcwhmslb,auvoethnly,nkegtaokri,esfhbrctno,ihfldytons}

545   {tpdcwhmslb,auioethnly,nkegtaokri,esfhbrctno,ihfldytons}

565   {tpdcwhmslb,auioethnly,nkegtaocri,esfhbrctno,ihfldytons}

571   {tpdcwhmslb,auioethnly,nkegtaocri,esfhwrctno,ihfldytons}

654   {tpdcwhmslb,auioethnly,nkegtaocri,esfhwrctno,ihfedytons}

671   {tpdcwhmslb,auioethnly,nkegtaocri,esfhirctno,ihfedytons}

731   {tpdcwhmslb,auioethnly,nkegtaocri,esfhirctno,ihredytons}

746   {tpdcwhmslb,arioethnly,nkegtaocri,esfhirctno,ihredytons}

755   {tpdcwhmslb,arioethnuy,nkegtaocri,esfhirctno,ihredytons}

772   {tpdcwhmslb,arioethnuy,nkegtaocri,ekfhirctno,ihredytons}

786   {tpdcwhmslb,arioethnuy,nkegtaocri,ekfhirctno,lhredytons}

796   {tpdcwhmslb,arioethnuy,nkegtaocri,ekfhgrctno,lhredytons}

804   {tpdcwhmslb,arioethwuy,nkegtaocri,ekfhgrctno,lhredytons}

817   {tpdcwhmslb,arioethwuy,nklgtaocri,ekfhgrctno,lhredytons}

834   {tpdcwhmslb,arioethwuy,nklgtaocri,ekfhdrctno,lhredytons}

844   {tpdcwhmslb,arioethwup,nklgtaocri,ekfhdrctno,lhredytons}

887   {tpdcwhmslb,arioethwup,nklgtaocri,ekshdrctno,lhredytons}

901   {tpdcwhmslb,arioethwup,nklgtaouri,ekshdrctno,lhredytons}

966   {tpdcwhmslb,arioethwup,nklgtaouri,elshdrctno,lhredytons}

986   {tpdcwhmsfb,arioethwup,nklgtaouri,elshdrctno,lhredytons}

1015   {tpdcwhmsfb,arioethwup,nklgtaouri,elsidrctno,lhredytons}

1039   {tpdcwhmsfb,arioethwup,nklgtaouri,elsidrctno,khredytons}

1051   {tpdcwhmsfb,arioethwup,nklgtaouri,elskdrctno,khredytons}

1055   {tpdcwhmsfb,arioethwup,nklgtaouri,elskdrctno,khredytlns}

1115   {tpdcwhmsfb,arioethwup,nelgtaouri,elskdrctno,khredytlns}

1131   {tpdcwhmsfb,arioethwup,nelwtaouri,elskdrctno,khredytlns}

1149   {tpdcwhmsfb,arioethwup,nelwtaouri,elskdrctna,khredytlns}

1212   {tpdcwhmsfb,arioelhwup,nelwtaouri,elskdrctna,khredytlns}

1249   {tpdcwhmsfb,arioelhwup,nelstaouri,elskdrctna,khredytlns}

1251   {tpgcwhmsfb,arioelhwup,nelstaouri,elskdrctna,khredytlns}

1255   {tpgcwdmsfb,arioelhwup,nelstaouri,elskdrctna,khredytlns}

1258   {tpgcwdmsfb,arioelhwup,nelstaouri,elskdrctna,khredytlas}

1262   {tpgcwdmsfb,arioelhwut,nelstaouri,elskdrctna,khredytlas}

1275   {tpgcwdmsfb,arioelhput,nelstaouri,elskdrctna,khredytlas}

यहाँ कुछ अन्य "जीत" चयन हैं:

{"cbpmsftgwd", "hriuoepatl", "euosrtanli", "clknsaredt", "yhlkdstare"}
{"wptdsgcbmf", "ohlutraeip", "erotauinls", "lknectdasr", "sytrhklaed"}
{"cftsbwgmpd", "ropilhtaue", "niauseltor", "clstnkdrea", "esdrakthly"}
{"smgbwtdcfp", "ihulpreota", "ianrsouetl", "ekndasctlr", "kehardytls"}

जैसा कि पीटर की टिप्पणी है कि ये वास्तव में विभिन्न आदेशों में समान समाधान हैं। छाँटे गए:

{"bcdfgmpstw", "aehiloprtu", "aeilnorstu", "acdeklnrst", "adehklrsty"}

@ अविशासन धन्यवाद! यह ENABLE2k के साथ अधिक दिलचस्प है ।
श्री। छिपकली

मैं इस एक के लिए Combinatorica's NetworkFlow पर विचार कर रहा हूं, लेकिन इसे इस्तेमाल करने का कोई उपयोगी तरीका नहीं मिला है
डॉ। बेलिसरियस

@ मुझे विश्वास है कि आपको एक रास्ता मिल जाएगा; मुझे वह देखना है।
श्री। छिपकली २४'१३ को १ .:१

जिस तरह से मेरा कोड shortlistलंबे समय के लिए लगता है, और हालांकि यह गोल्फ नहीं है, मैं कुछ छोटा करूँगा। क्या आप मदद कर सकते हैं?
श्री। छिपकली

1
मुझे लगता है कि आपके "विजेता" चयन डायल के भीतर सभी एक ही मोडुलो क्रमांकन हैं।
पीटर टेलर

2

पायथन, 1210 शब्द (~ 29%)

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

word_list = [line.upper()[:-1] for line in open('linuxwords.txt','r').readlines() if len(line) == 6]
cur_list = word_list
s = ['']*5
for i in range(5):
    count = [0]*26
    for j in range(26):
        c = chr(j+ord('A'))
        count[j] = len([x for x in cur_list if x[i] == c])
    s[i] = [chr(x+ord('A')) for x in sorted(range(26),lambda a,b: count[b] - count[a])[:10]]
    cur_list = filter(lambda x:x[i] in s[i],cur_list)
for e in s:
    print ''.join(e)
print len(cur_list)

कार्यक्रम आउटपुट

SBCAPFDTMG
AOREILUHTP
ARIOLENUTS
ENTLRCSAID
SEYDTKHRNL
1210

अच्छा है, और मेरे चेकर में 1210 काम करता है।
ब्रिगैंड

1

iPython ( 273 210 बाइट्स, 1115 शब्द)

1115/4176 * ~ 27%

मैंने iPython में इनकी गणना की, लेकिन मेरा इतिहास (डिबगिंग को हटाने के लिए छंटनी) इस तरह दिखता था।

with open("linuxwords") as fin: d = fin.readlines()
x = [w.lower().strip() for w in d if len(w) == 6]
# Saving for later use:
# with open("5letter", "w") as fout: fout.write("\n".join(x))
from string import lowercase as low
low=lowercase + "'"
c = [{a:0 for a in low} for q in range(5)]
for w in x:
    for i, ch in enumerate(w):
        c[i][ch] += 1

[''.join(sorted(q, key=q.get, reverse=True)[:10]) for q in c]

अगर हम कम के लिए जा रहे हैं; मैं इसे इसके लिए ट्रिम कर सकता हूं।

x = [w.lower().strip() for w in open("l") if len(w)==6]
c=[{a:0 for a in"abcdefghijklmnopqrstuvwxyz'-"}for q in range(5)]
for w in[w.lower().strip()for w in open("l") if len(w)==6]:
 for i in range(5):c[i][w[i]]+=1
[''.join(sorted(q,key=q.get,reverse=True)[:10])for q in c]

छोटा:

c=[{a:0 for a in"abcdefghijklmnopqrstuvwxyz'-"}for q in range(5)]
for w in[w.lower() for w in open("l")if len(w)==6]:
 for i in range(5):c[i][w[i]]+=1
[''.join(sorted(q,key=q.get,reverse=True)[:10])for q in c]

मेरे परिणाम थे: ['sbcapfdtmg', 'aoeirulhnt', 'aironeluts', 'etnlriaosc', 'seyrdtnlah']

* ४१ may६ पर मेरा गणित हाइफ़न या एपोस्ट्रोफ के साथ शब्दों को छोड़ने के कारण थोड़ा छोटा हो सकता है


1
जबकि यह समाधान एक अच्छा अनुमान है और संभवतः एक अच्छा समाधान वापस आ जाएगा, मुझे विश्वास नहीं है कि यह इष्टतम समाधान वापस करने की गारंटी है। कारण यह है कि आप रीलों के बीच बाधाओं को नहीं पकड़ रहे हैं: आप प्रत्येक रील को एक स्वतंत्र चर के रूप में मान रहे हैं जब वास्तव में वे निर्भर होते हैं। उदाहरण के लिए, यह मामला हो सकता है कि जो शब्द सबसे आम पहले अक्षर को साझा करते हैं, उनके दूसरे पत्र के वितरण में एक बड़ा विचरण होता है। यदि ऐसा है, तो आपका समाधान रीलों के संयोजन का उत्पादन कर सकता है जो वास्तव में किसी भी शब्द की अनुमति नहीं देते हैं।
११:१३

1

क्यू

? (टूडू) शब्द

शब्दों को एक फ़ाइल में संग्रहीत किया जाना चाहिए जिसे कहा जाता है words

(!:')10#/:(desc')(#:'')(=:')(+:)w@(&:)(5=(#:')w)&(&/')(w:(_:)(0:)`:words)in\:.Q.a

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

परिणाम:

"sbcapfdtmg"
"aoeirulhnt"
"aironeluts"
"etnlriaosc"
"seyrdtnlah"

आपको कितने 5 अक्षर शब्द मिले?
डेविड

मैंने अजगर में ऐसा ही किया और 16353 मिला।
कार्डबोर्ड_बॉक्स

यह FakeRainBrigand के रूप में एक ही लालची एल्गोरिथ्म है?
पीटर टेलर

1
@cardboard_box, आपका परिणाम निश्चित रूप से गलत है। शब्दकोश में कई 5-अक्षर शब्द नहीं हैं।
पीटर टेलर

1
हां, यह 1115 है। मैंने सही शब्दों की संख्या के बजाय किसी भी शब्द में सही अक्षरों की संख्या गिना। मुझे लगता है कि मुझे एक और कॉफी की जरूरत है।
कार्डबोर्ड_बॉक्स

0

संपादित करें: अब जब नियमों को संशोधित किया गया है, तो यह दृष्टिकोण अयोग्य है। जब तक मैं अंततः नए नियमों के लिए इसे संशोधित करने के लिए चारों ओर हो रहा हूँ, किसी को भी दिलचस्पी है, मैं इसे यहाँ छोड़ने जा रहा हूँ।

अजगर: 277 वर्ण

मुझे पूरा यकीन है कि इस समस्या का सामान्यीकृत संस्करण एनपी-हार्ड है, और प्रश्न को सबसे तेज़ समाधान खोजने की आवश्यकता नहीं है , इसलिए यहां यह करने का एक क्रूर-बल तरीका है:

import itertools,string
w=[w.lower()[:-1] for w in open('w') if len(w)==6]
v=-1
for l in itertools.product(itertools.combinations(string.ascii_lowercase,10),repeat=5):
 c=sum(map(lambda d:sum(map(lambda i:i[0] in i[1],zip(d,l)))==5,w))
 if c>v:
  v=c
  print str(c)+" "+str(l)

ध्यान दें कि मैंने कुछ वर्णों को सहेजने के लिए शब्द सूची फ़ाइल को सिर्फ "w" नाम दिया है।

आउटपुट उन शब्दों की संख्या है जो किसी कॉन्फ़िगरेशन से संभव हैं, जो कॉन्फ़िगरेशन के बाद आता है:

34 (('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'))
38 (('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'k'))
42 (('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'l'))
45 (('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'n'))
50 (('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'r'))
57 (('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 's'))
60 (('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'k', 's'))
64 (('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'l', 's'))
67 (('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'n', 's'))
72 (('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'), ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'r', 's'))
...

कार्यक्रम समाप्त होने से पहले आउटपुट की अंतिम पंक्ति को इष्टतम समाधान होने की गारंटी है।


मुझे आपके कोड का C या ASM संस्करण देखना अच्छा लगेगा, ताकि यह वास्तव में इस वर्ष समाप्त कर सके :-) या कम से कम इसे तब तक चलाएं जब तक कि यह 1116 तक न हो जाए। क्या आप इसे इटर्स्टूल के बिना लिख ​​सकते हैं, इसलिए मैं इसे jython पर चला सकता हूं ? (तेजी से नियमित रूप से अजगर से, लेकिन cython की तुलना में आसान।)
बटमार

जाइथॉन बात के बारे में कभी नहीं। मुझे अल्फाज हथियाने की जरूरत थी। यह अभी भी दुर्घटनाग्रस्त हो गया (बहुत अधिक मेमोरी) लेकिन यह अपरिहार्य प्रतीत होता है।
ब्रिगैंड

मुझे पूरा यकीन है कि भले ही इसे विधानसभा में लागू किया गया हो लेकिन वर्तमान हार्डवेयर पर पूरा होने में मेरे जीवनकाल की तुलना में अधिक समय लगेगा :-P
ESultanik

मुद्दा यह है कि मैं (26 चुनिंदा 10) ^ 5 3 4.23 * 10 ^ 33 संभावनाएं देख रहा हूं। यहां तक ​​कि अगर हम प्रति नैनोसेकंड की एक संभावना का परीक्षण कर सकते हैं, तो ब्रह्मांड की वर्तमान आयु समाप्त होने में लगभग 10 ^ 7 गुना लगेगा।
ESultanik

1
दो अक्षर हैं जो दिए गए शब्द सूची में किसी भी शब्द में 5 वें स्थान पर नहीं आते हैं, इसलिए आप लगभग 4 के कारक द्वारा संभावनाओं की संख्या को कम कर सकते हैं। इस तरह से मुझे अपनी टिप्पणी में "लगभग 110.3 बिट्स" मिल गए हैं प्रश्न।
पीटर टेलर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.