वाक्य को फिर से बनाएँ

Question

इस चुनौती में दो भाग होते हैं। विजेता सबसे कम कुल बाइट गिनती के साथ समाधान होगा। दोनों चुनौतियों के लिए एक ही भाषा का उपयोग किया जाना चाहिए।

भाग 1:

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

मैं उदाहरण और विस्तृत नियम आगे जोड़ूंगा।

भाग 2:

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

अधिक जानकारी। नियम और प्रतिबंध:

भाग 1:

• पहला इनपुट किसी भी उपयुक्त प्रारूप पर हो सकता है, उद्धरण चिह्नों के साथ या बिना, फ़ंक्शन तर्क के रूप में या एसटीडीआईएन के साथ, ब्रैकेट आदि के साथ या बिना।
• अंत में एक अवधि / डॉट को छोड़कर इनपुट वाक्य में कोई विराम चिह्न या विशेष वर्ण नहीं होंगे। अवधि प्रतीक को छोड़कर, सभी वर्ण जो इनपुट में हैं, शब्द सूची में होंगे।
• सजा का पहला अक्षर ऊपरी मामला होगा, बाकी निचला मामला होगा।
• भाग 2 का आउटपुट मूल वाक्य के समान ऊपरी अक्षर से शुरू होना चाहिए (इसलिए इनपुट को निचले मामले में परिवर्तित करने की अनुशंसा नहीं की जाती है (लेकिन ठीक है)।
• आउटपुट किसी भी उपयुक्त प्रारूप पर हो सकता है:
  • आउटपुट को अगले प्रोग्राम / फ़ंक्शन में सीधे कॉपी-पेस्ट करना संभव होगा
  • कॉपी-पेस्ट करते समय कोई परिवर्तन नहीं किया जा सकता है, पूरे आउटपुट को कॉपी किया जाना चाहिए और एक पूरे के रूप में चिपकाया जाना चाहिए, भागों में नहीं।
  • उदाहरण के लिए आप वर्णमाला के सभी अक्षरों का एक हिस्टोग्राम या केवल उपयोग किए जाने वाले (सामान्य रूप से, जो भी आवश्यक हो 2) को पूरा करने के लिए कर सकते हैं
  • आप उन वर्णों की सूची को आउटपुट नहीं कर सकते हैं जहां कई बार पुनरावृत्तियां होती हैं। उदाहरण के लिए, The queueकोई आउटपुट नहीं दे सकता:, Teeehquu (3,5)यह कुछ इस तरह होना चाहिए Tehqu, (1 3 1 1 2),(3 5):।

भाग 2:

• प्रोग्राम / फ़ंक्शन को इनपुट को उसी तरह स्वीकार करना चाहिए जैसा कि भाग 1 (एक अपवाद है, फ़ाइल नाम इनपुट के रूप में लेने के बारे में नीचे टिप्पणी देखें)।
  • यदि आसपास के कोष्ठक, उद्धरण चिह्न या इसी तरह के इनपुट को पार्स करने के लिए आवश्यक हैं, तो ये भाग 1 से आउटपुट का हिस्सा होना चाहिए।
• शब्द सूची यहां पाई जा सकती है।
  • शब्द सूची को या तो स्थानीय रूप से सहेजा जा सकता है w.txt, या इसे url से प्राप्त किया जा सकता है। Url केवल 5 बाइट्स के रूप में गिना जाएगा, इसलिए आपको url-shortener की आवश्यकता नहीं है।
  • कार्यक्रम stdin से एक इनपुट के रूप नाम पढ़ने के बिना एक फ़ाइल नहीं खोल सकता है (मेरा मानना है कि यह है कि कम से कम Pyth के लिए मामला था), तो फ़ाइल नाम एक अलग इनपुट तर्क के रूप में लिया जा सकता है।
• आउटपुट केवल एक वाक्य (मान्य शब्दों की सूची) होना चाहिए, जो एक अवधि और एक वैकल्पिक न्यूलाइन के साथ समाप्त होगा।
  • भाग 1 में (सही क्रम में) मूल वाक्य के समान ही अक्षरों में आउटपुट के साथ शब्द होने चाहिए
  • मूल वाक्य में उपयोग किए गए सभी अक्षरों को नए आउटपुट में उपयोग किया जाना चाहिए।
  • वाक्य को मूल इनपुट वाक्य के समान ऊपरी अक्षर से शुरू करना चाहिए और एक अवधि के साथ समाप्त होना चाहिए।

दोनों भाग:

• न तो भागों को निष्पादित करने के लिए 2 मिनट से अधिक समय लेना चाहिए (जब तक कि किसी समाधान तक नहीं पहुंच जाता है तब तक शब्दों को बाहर निकालना) स्वीकार नहीं किया जाता है।

ऊपर सूचीबद्ध नियमों के साथ, एक उचित मौका होना चाहिए कि ठीक उसी वाक्य को पुन: पेश किया जाए, हालांकि यह एक आवश्यकता नहीं है।

उदाहरण:

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

भाग 1:

इनपुट:

Zulus win.

आउटपुट प्रकार 1:

Z i l n s u w
1 1 1 1 1 2 1
5 3

आउटपुट प्रकार 2:

(('Z',1),('i',1),('l',1),('n',1),('s',1),('u',2),('w',1)), (5,2)

आउटपुट प्रकार 3:

'Zilnsuuw',[1,1,1,1,1,2,1],[5,2]

भाग 2:

इनपुट: भाग 1 से आउटपुट की एक सटीक प्रतिलिपि। आउटपुट:

Zulus win.

ध्यान दें कि अन्य शब्द संयोजन तब तक स्वीकार किए जाते हैं जब तक वे एक से शुरू करते हैं Z, और पहले शब्द में 5 अक्षर हैं और दूसरे में 3 हैं।

बाइट्स में सबसे छोटा कोड जीत जाता है।

Comments

यहाँ प्रतिबद्ध है: github.com/isaacg1/pyth/commit/…

— PurkkaKoodari

@ LegionMammal978: हां, आप इसे निम्न प्रतिबंधों के तहत कर सकते हैं: इसमें से f1जो आउटपुट चिपकाया गया है उसमें f2चुनौती में निर्दिष्ट सभी डेटा होने चाहिए। कोई अतिरिक्त डेटा आउटपुट का हिस्सा नहीं हो सकता है f1। इससे f1कॉल करते समय जानकारी उपलब्ध कराने में कोई डेटा "संग्रहीत" नहीं किया जा सकता है f2। f1प्रति कॉल इनपुट के रूप में केवल एक स्ट्रिंग ले सकते हैं।

— स्टिवे ग्रिफिन

3 से अधिक शब्दों के साथ एक ही वाक्य को बाहर निकालने का मौका वास्तव में बहुत बुरा है मुझे लगता है

— यूमेल

सामान्य तौर पर हां, लेकिन ऐसे कई मामले हैं जहां आपको समान सजा मिलने की संभावना है। यदि आपकी दादी आपके पुराने स्वेटर को पुनः प्राप्त करने से थक गई है, तो वह हो सकती है: "बुनाई बुनाई छोड़ देना"। मैंने जाँच नहीं की है, लेकिन मुझे लगता है कि आपकी दादी अभी भी भाग 2 के बाद छोड़ देगी। लंबे शब्दों के संयोजन भी एक ही वाक्य वापस दे सकते हैं।

— स्टीवी ग्रिफिन

@StewieGriffin आप आसानी से "विग ... वाह" प्राप्त कर सकते हैं। उदाहरण वाक्य के साथ वापस।

— question_asker

Answer 1

लैबव्यू, 166 लैब व्यू आदिम

सबसे पहले मैंने 2 अलग प्रोग्राम नहीं बनाए क्योंकि Labview डेटाफ्लो करता है इसलिए वास्तव में कोई ज़रूरत नहीं है।

पहले तत्व के साथ हिस्टोग्राम को बचाता है = 1-26 से पहले अक्षर के बाकी के कोड को राशि द्वारा जाना जाता है। लेनिंग बस एक सरणी में बच जाता है।

पहले शब्द में हिस्टोग्राम में 3 चेक, पहला अक्षर, लिंच और उपलब्ध पत्र हैं। पहला अक्षर चेक पहले शब्द के बाद बंद हो जाता है।

मैं हिस्टोग्राम को हर अक्षर के लिए घटाकर जांचता हूं और जांचता हूं कि क्या यह 0 से नीचे होगा।

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

यह उन वाक्यों के लिए काम कर सकता है या नहीं हो सकता है, क्योंकि यह गणना करने के लिए हमेशा के लिए ले जाएगा (मेरा उदाहरण पहले ही कुछ सेकंड लिया गया था)।

मैंने क्या कोशिश की

In: Zulus win.
Out: Zulus win.

In: Dovecot flagships oleander.
Out: Dolphin advocates forelegs.

In: Abash abel mammal test.
Out: Amass abbe hamlet malt.

Answer 2

पायथन 2.7, 353 बाइट्स

दुर्भाग्य से, मैं वास्तविक w.txt फ़ाइल एटीएम के साथ इसका परीक्षण नहीं कर सकता, क्योंकि Android के लिए QPython फ़ाइल I / O को संभाल नहीं सकता है। यह मेरे द्वारा कॉपी और पेस्ट किए गए डेटा के साथ काम करता है।

भाग 1, 76 बाइट्स

h=lambda s:({c:s.count(c)for c in s if c.isalnum()},map(len,s[:-1].split()))

में: 'Hi there.'

बाहर: {'H':1, 'i':1, 't':1, 'h':1, 'e':2, 'r':1}, (2, 5)

तो, एक सूची युक्त:

• हिस्टोग्राम के साथ एक हैशमैप

• पत्र मायने रखता है की एक सूची

भाग 2, 277 बाइट्स

import itertools as i
m=lambda c:' '.join([s for s in i.product(*[[w for w in open('w.txt')if len(w)==length]for length in c[1]])if sorted(''.join(s))==sorted(sum([[k.lower()]*n for k,n in c[0].items()],[]))and s[0][0]==filter(str.isupper,c[0])[0].lower()][0]).capitalize()+'.'

मुझे खुशी है कि मैं इसे 100% शुद्ध कार्यात्मक बनाने में कामयाब रहा। यकीन नहीं होता है कि अगर यह वास्तविक गोल्फ के साथ मदद करता है, लेकिन मुझे निश्चित रूप से मोटापा भाग सही मिला है: डी यहां पीटी का एक अधिक मानवीय अनुकूल संस्करण है। 2 (बिल्कुल समान प्रवाह, लेकिन चर नामों के साथ):

from itertools import product

def matching(counts):
  histo, word_lengths = counts
  first_letter = filter(str.isupper, histo)[0].lower()

  letters_nested = [ [char.lower()]*count for char, count in histo.items() ]
  letters = sum(letters_nested, [])

  word_options = [[word for word in open('w.txt') if len(word)==length] for length in word_lengths]

  sentences = product(*word_options)

  valid = [sentence for sentence in sentences if sorted(''.join(sentence))==sorted(letters) and sentence[0][0]==first_letter]
  return ' '.join(valid[0]).capitalize()+'.'

Answer 3

पर्ल, 516 504 बाइट्स

के लिए 2x +1 शामिल है -p

@l=map{length}/\w+/g;s/\w/$c{$&}++/eg;@h=map{"$_$c{$_}"}keys%c;$_="@h @l";chomp(@w=`cat w.txt`);s/([A-Z])1//;$o=$1;s/(\w)(\d)/$h{$1}=$2,''/eg;@L=/\d/g;$l=shift@L;@O=$_,s/^.//,g([@L],%h)&&last for grep{$l==length&&/^$o/i&&h(\%h,substr$_,1)}@w;$_="@O.";s/^./uc$&/e;sub g{my%g;($R,%g)=@_;my@R=@$R;if($j=shift@R){s/./$g{$&}--/eg;my@C=grep{$j==length&&h(\%g,$_)}@w;push(@O,$_),g([@R],%g)and return 1 or pop@O for@C;0}else{1}}sub h{($y,$z)=@_;my%T;$z=~s/\w/$T{$&}++/eg;$K=1;$K&=$T{$_}<=$y->{$_}for keys%T;$K}

के लिए आवश्यक है w.txtमें यूनिक्स प्रारूप ( \nलाइन अंत)। catफ़ाइल पढ़ने के लिए उपयोग करता है; typeविंडोज़ के लिए परिवर्तन ।
ऊपर 534.plऔर नीचे चलाने के रूप में oneliner सहेजें echo Test. | perl -p 534.pl।

बहुत बड़ा है, लेकिन यह एक शुरुआत है - बहुत सारे गोल्फिंग अवसर, लेकिन मैं सिर्फ लैबव्यू उत्तर को अकेला बनाने के लिए इसे पोस्ट करना चाहता था; ;-)। मैंने उप-सेकंड निष्पादन के लिए अनुकूलन को छोड़ दिया है, 30+ बाइट्स बचा रहा है।

---

पहला स्निपेट (73 बाइट्स):

@l=map{length}/\w+/g;s/\w/$c{$&}++/eg;@h=map{"$_$c{$_}"}keys%c;$_="@h @l"

यह एक हिस्टोग्राम और कॉम्पैक्ट प्रारूप में शब्द lenghts का उत्पादन करता है। इनपुट के लिए Zulus win.यह बिना टाइप -2 आउटपुट तैयार करता है (,), जो यहां आवश्यक नहीं हैं:

s1 l1 u2 Z1 w1 i1 n1 5 3

यहाँ यह है, ungolfed:

sub i{
    $_=shift;                       # get parameter
    @l = map{length} /\w+/g;        # cound word lengths
    s/\w/$c{$&}++/eg;               # count letters in hash %c
    @h=map{"$_$c{$_}"}keys%c;       # construct letter-frequency pairs
    "@h @l"                         # implicit interpolation with $" (space) separator
}

दूसरा स्निपेट (441 बाइट्स)

यह मुख्य भाग I / O और पहले अक्षर के विशेष उपचार से संबंधित है, जो सबरूटीन्स का उपयोग करता है gऔर hजो नीचे सूचीबद्ध हैं।

sub o {
    $_=shift;
    chomp(@w=`cat w.txt`);          # load the wordlist.

    s/([A-Z])1//; $o=$1;            # get and remove the uppercase character,
    s/(\w)(\d)/$h{$1}=$2,''/eg;     # reconstruct histogram in hash %h.
    @L=/\d/g;                       # get the word counts.

    $l = shift @L;                  # get the first word length.

    @O = $_,                        # initialize output with first word,
    s/^.//,                         # strip first char of word
    g([@L],%h) && last              # call the main algoritm and quit on success

    for grep {                      
            $l==length &&           # check length
            /^$o/i &&               # only match words starting with the uppercase char
            h(\%h,substr$_,1)       # check if the word satisfies the histogram
        } @w;                       # iterates all words (speedups removed).

    $_="@O.";                       # construct output sentence.
    s/^./uc$&/e;                    # make first char uppercase.
    $_
}

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

sub g {
    my%g;                           # local version of histogram
    ($R,%g)=@_;                     # get parameters.
    my@R=@$R;                       # dereference arrayref copy of word lengths.

    if($j=shift @R)                 # get the next word-length.
    {
        s/./$g{$&}--/eg;            # update histogram

        my @C =                     # get a list of suitable words.
        grep { $j==length && h(\%g,$_) }
        @w;

        push(@O,$_),                # append word to output
        g( [@R], %g )               # recurse.
            and return 1            # true: append word we're done.
            or pop @O               # remove word from output
        for @C                      # (for some reason the @C=grep doesn't work here)

        ;0
    } else { 1 }                    # no more words, done!
}

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

# check if first histogram is within bounds of second
sub h{
    ($y,$z)=@_;
    my%T; $z =~ s/\w/$T{$&}++/eg;    # calc histogram

    $K=1;
    $K &= $T{$_} <= $y->{$_}
    for keys %T;#$_[0];
    $K
}

आप sub i/o/g/hएक फ़ाइल में अनगोल्ड स्निपेट्स ( ) पेस्ट कर सकते हैं और नीचे दिए गए परीक्षण कोड को जोड़ सकते हैं।

sub t {
    print $i=i(shift),$/,o($i),$/x2;
    %c=%h=@L=@X=@O=();
}

t "Test.";                              # Test.
t "Zulus win.";                         # Zulus win.
t "Happy solstice.";                    # Happy solstice.
t "Abash abel mammal test.";            # Abase alms embalm that.
t "Dovecot flagships oleander.";        # Dangled horoscope festival.
t 'This code requires further golfing.';# Tech deer fighting ferrous liquors.

---

• अद्यतन 504 : एक substrऔर एक पैरामीटर को समाप्त करने के लिए 12 बाइट्स सहेजें sub g।

Comments

मैं देख रहा हूँ, मेरे उदाहरण चोरी! बस रासलीलाओं का मजाक उड़ाते हुए प्रफुल्लित करने वाले XD हैं

— Eumel

@Eumel हाँ, वे आप से अलग थे इसलिए मैंने उन्हें शामिल किया :-)

— केनी