फूरियर में गोल्फ के तार


24

चुनौती

इनपुट के रूप में एक स्ट्रिंग को देखते हुए, फूरियर प्रोग्राम को नीचे गिरा दिया जाता है जो उस स्ट्रिंग को आउटपुट करता है।

फूरियर में एक स्ट्रिंग को आउटपुट करने का कोई आसान तरीका नहीं है: आपको प्रत्येक चरित्र कोड और आउटपुट के माध्यम से जाना होगा।

फूरियर

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

चरित्र बाहर

a

संचायक के मान को ASCII कोड के रूप में लेता है और वर्ण को आउटपुट करता है। संचायक का मान नहीं बदलता है।

यदि संचायक 255 से अधिक है, तो प्रोग्राम एक त्रुटि लौटाएगा। इसी तरह अगर संचायक 0 से कम है।

नंबर बाहर

o

संचायक के मूल्य को आउटपुट करता है। संचायक का मान नहीं बदलता है।

बढ़ना

^

संचायक को एक से बढ़ाएं।

कमी

v

संचायक को एक से घटाएं।

जोड़ना

+x

संचायक को संचयकर्ता के मान से और x के मान को सेट करता है।

घटाना

-x

संचायक को x के मान को संचायक के मान पर सेट करता है।

गुणा

*x

संचायक के मान को x के मान से गुणा करने पर संचायक को सेट करता है।

फूट डालो

/x

संचायक को x के मान से विभाजित संचायक के मान में सेट करता है। (ध्यान दें कि यह पूर्णांक विभाजन है, इसलिए 1/6परिणाम 0)

संख्या

n

संचायक को पूर्णांक n पर सेट करें।

ध्यान दें

यहाँ, xऔर nसे किसी भी पूर्णांक हो सकती 0करने के लिए 2^32-1समावेशी।

अधिक जानकारी

आपको केवल ऊपर वर्णित ऑपरेटरों का उपयोग करना होगा। इसलिए यदि आपका आउटपुट फ़ॉयर प्रोग्राम अमान्य है, तो यह निम्नलिखित में से किसी का भी उपयोग करता है (ध्यान दें कि बाउंटी के लिए निम्नलिखित ऑपरेटरों को अनुमति दी गई है):

  • बार-बार लूप
  • यदि कथन
  • चर
  • बिना सोचे समझे
  • modulo
  • उपयोगकर्ता का निवेश
  • ऑपरेटरों से अधिक / कम
  • समानता ऑपरेटरों
  • साफ़ स्क्रीन
  • समय विलंब
  • दिनांक कार्य

आपका कार्यक्रम या तो एक पूर्ण कार्यक्रम या फ़ंक्शन हो सकता है, एसटीडीआईएन के माध्यम से इनपुट में ले रहा है, एक फ़ाइल या फ़ंक्शन तर्क। आप इंटरनेट से सीधे इनपुट भी ले सकते हैं।

ध्यान दें कि यदि vvआपके कोड में कोई है, तो आपको इसे बदल देना चाहिए -2। उसी के लिए जाता है ^^, इसके साथ बदल रहा है +2

उदाहरण

यदि इनपुट है 7n, तो अपेक्षित कार्यक्रम है:

55a110a

लेकिन आप एक बाइट के साथ बचा सकते हैं

55a*2a

दूसरा तरीका है

7o110a

नंबर का उपयोग करना।


इसी प्रकार यदि इनपुट है Hello, तो अपेक्षित कार्यक्रम है:

72a101a108a108a111a

आप इसे 3 बाइट्स से बंद कर सकते हैं (क्योंकि आउटपुट संचयक को नहीं बदलता है):

72a101a108aa111a

लेकिन रुकिए, हम 2 बाइट्स बचाते हुए अतिरिक्त ऑपरेटर का उपयोग कर सकते हैं:

72a101a+7aa+3a

का प्रारूपण

क्योंकि मैं मार्टिन बंटनर के स्टैक स्निपेट लीडरबोर्ड का उपयोग कर रहा हूं, कृपया आप इस तरह शीर्षक को प्रारूपित कर सकते हैं:

# <Language name>, <length of total output> bytes

फिर, आप शीर्षक के नीचे अपनी इच्छा के अनुसार कुछ भी रख सकते हैं।

जीतना

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

सबसे कम स्कोर वाला व्यक्ति जीतता है। यदि कोई टाई है, तो बाइट्स में सबसे छोटा प्रोग्राम जीत जाता है।

इनाम

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

लीडरबोर्ड

ऊपर स्वरूपण अनुभाग देखें:

var QUESTION_ID=55384;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),e.has_more?getAnswers():process()}})}function shouldHaveHeading(e){var a=!1,r=e.body_markdown.split("\n");try{a|=/^#/.test(e.body_markdown),a|=["-","="].indexOf(r[1][0])>-1,a&=LANGUAGE_REG.test(e.body_markdown)}catch(n){}return a}function shouldHaveScore(e){var a=!1;try{a|=SIZE_REG.test(e.body_markdown.split("\n")[0])}catch(r){}return a}function getAuthorName(e){return e.owner.display_name}function process(){answers=answers.filter(shouldHaveScore).filter(shouldHaveHeading),answers.sort(function(e,a){var r=+(e.body_markdown.split("\n")[0].match(SIZE_REG)||[1/0])[0],n=+(a.body_markdown.split("\n")[0].match(SIZE_REG)||[1/0])[0];return r-n});var e={},a=1,r=null,n=1;answers.forEach(function(s){var t=s.body_markdown.split("\n")[0],o=jQuery("#answer-template").html(),l=(t.match(NUMBER_REG)[0],(t.match(SIZE_REG)||[0])[0]),c=t.match(LANGUAGE_REG)[1],i=getAuthorName(s);l!=r&&(n=a),r=l,++a,o=o.replace("{{PLACE}}",n+".").replace("{{NAME}}",i).replace("{{LANGUAGE}}",c).replace("{{SIZE}}",l).replace("{{LINK}}",s.share_link),o=jQuery(o),jQuery("#answers").append(o),e[c]=e[c]||{lang:c,user:i,size:l,link:s.share_link}});var s=[];for(var t in e)e.hasOwnProperty(t)&&s.push(e[t]);s.sort(function(e,a){return e.lang>a.lang?1:e.lang<a.lang?-1:0});for(var o=0;o<s.length;++o){var l=jQuery("#language-template").html(),t=s[o];l=l.replace("{{LANGUAGE}}",t.lang).replace("{{NAME}}",t.user).replace("{{SIZE}}",t.size).replace("{{LINK}}",t.link),l=jQuery(l),jQuery("#languages").append(l)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*$)/,NUMBER_REG=/\d+/,LANGUAGE_REG=/^#*\s*([^,]+)/;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table></div> <tbody id="languages"> </tbody> </table></div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody></table>


6
मुझे नहीं लगता कि सभी इष्टतम समाधानों का उत्पादन करना बहुत उचित / दिलचस्प है। यह क्रूर बल को छोड़कर सभी कार्यान्वयनों को
नियंत्रित करता है

5
सभी इष्टतम समाधानों के आउटपुट के साथ वास्तविक समस्या यह है कि लंबे इनपुट के लिए, अधिक इष्टतम समाधान होंगे तब ब्रह्मांड में परमाणु होते हैं।
isaacg

1
@orlp ने सभी इष्टतम समाधानों का उत्पादन किया
बीटा

1
क्या यह केवल मुद्रण योग्य एएससीआईआई, या एएससीआईआई के किसी भी प्रकार का होना चाहिए? और केवल 7-बिट ASCII, या पूर्ण बाइट्स?
orlp

1
क्या संचायक 0 पर शुरू होता है?
ASCIIThenANSI

जवाबों:


9

पायथन, 14307118 बाइट्स

हैमलेट के लिए 601216 + उत्पत्ति के लिए 13705902 = 14307118

कुछ निश्चित रूप से कुछ गलतियां हैं जिनके तहत यह समाधान इष्टतम नहीं है, जैसे कि 1111, जहां यह 1111oविरोध के रूप में आउटपुट करेगा11oo । हालांकि, मुझे लगता है कि यह लगभग इष्टतम है।

संपादित करें: में सुधार करके कुछ बाइट्स सहेजे 0o0oगए 0oo

इनपुट युक्त फ़ाइल का नाम STDIN पर प्राप्त होता है, STDOUT में आउटपुट होता है।

आधिकारिक दुभाषिया के साथ सत्यापित परिणाम।

def opt_str(char, acc):
    opts = []
    char_num = ord(char)
    opts.append(str(char_num))
    if 0 < char_num - acc < 10:
        opts.append('+' + str(char_num - acc))
    if 0 < acc - char_num < 10:
        opts.append('-' + str(acc - char_num))
    if char_num - acc == 1:
        opts.append('^')
    if acc - char_num == 1:
        opts.append('v')
    if acc == char_num:
        opts.append('')
    if acc and char_num % acc == 0:
        opts.append('*' + str(char_num//acc))
    try:
        if acc // (acc // char_num) == char_num:
            opts.append('/' + str(acc // char_num))
    except:
        pass
    return [opt for opt in opts if len(opt) == len(min(opts, key=len))]

acc = 0
result = []
pos = 0
with open(input(), "r") as myfile:
        in_str = myfile.read()
while pos < len(in_str):
    i = in_str[pos]
    pos += 1
    if i in '0123456789':
        if i != '0':
            while pos < len(in_str) and in_str[pos] in '0123456789':
                i += in_str[pos]
                pos += 1
        if i == str(acc):
            result.append('o')
        else:
            result.append(i + 'o')
        acc = int(i)
    else:
        opts = opt_str(i, acc)
        result.append(opts[0] + 'a')
        acc = ord(i)
print(''.join(result))

@ शेबंग खैर, मुझे पूरा यकीन है कि जियोबिट का परिणाम गलत है, मेरी टिप्पणियों को देखें।
isaacg

इसमें बहुत कम था, लेकिन आप केवल 5 वर्णों से जीते थे (आप और रजवान ने बंधे थे इसलिए मैंने आपके कोड की लंबाई टाईब्रेकर के रूप में इस्तेमाल की थी)
बीटा डिके

2
@ BetaDecay मैंने इससे पहले कभी भी असंगत कार्यक्रमों की एक जोड़ी के बीच लंबाई टाईब्रेकर को प्रासंगिक नहीं देखा है।
isaacg

हाँ ... मुझे न तो: पी
बीटा डेके

13

> <>, 14310665 बाइट्स

हैमलेट के लिए 601398 + 13709267 उत्पत्ति के लिए

यह अभी भी प्रगति पर है और इसे पूरा करने में बहुत समय लगता है।

v
0
>i:0(?;:r-:?!v:0a-)?v     v
  >~:v       ~      >:a(?v>
 :1+?v~'v'o  v      o'^'~\:0)?v
     >n      vno'+'      ^?=1:<
^        o'a'<

यह पागल छोटा है, शर्म की बात है हालांकि यह इष्टतम नहीं है।
orlp

मैं /, * और o के उपयोग पर काम कर रहा हूं, लेकिन यह कुछ और जगह लेना शुरू कर रहा है।
हारून

18
यह ठीक है, मछली सामान्य रूप से कहानी के प्रत्येक कहने के साथ बढ़ती है;)
जोबिट्स

खैर, यह भाषा का एक शानदार विकल्प है: डी
बीटा डेके

आपका कार्यक्रम बाउंटी (किसी भी पोस्ट किए गए उत्तर में से कोई भी) के लिए मानदंड फिट नहीं था, इसलिए मैंने आपको यह सम्मानित किया है क्योंकि मुझे लगता है कि आपने <> <का उपयोग किया है।
बीटा डेके

8

जावा, 14307140 बाइट्स

हेमलेट - 601,218

उत्पत्ति - 13,705,922

एक चरित्र-> चरित्र मानचित्र बनाकर, यहाँ विचार सभी कार्य को एक साथ करना है। तो आप बस के माध्यम से लूप कर सकते हैं और कम से कम तारों को पकड़ो।

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

इनपुट तर्क के रूप में एक फ़ाइल नाम है। आउटपुट एक फ़ाइल को लिखा जाता है inputFilename_out.4, और चरित्र गणना STDOUT को भेजी जाती है।

यह टाईब्रेकर के लिए 1737 बाइट्स है, पूरी तरह से अनफॉर्म्ड। जरूरत पड़ने पर मैं इसे गोल्फ कर सकता हूं, लेकिन यह अभी भी थोड़ा बड़ा होने जा रहा है।

import java.nio.file.Files;
import java.nio.file.OpenOption;
import java.nio.file.Paths;
import java.text.NumberFormat;

public class FourierMapper {
    public static void main(String[] args) throws Exception {
        FourierMapper fm = new FourierMapper();
        fm.createMap();
        String filename = args.length>0? args[0]:"bible.txt";
        String out = fm.fourierize(filename);
        System.out.println(out.length());
        Files.write(Paths.get(filename + "_out.4"), out.getBytes(), new OpenOption[]{});
    }

    String[][] map = new String[9999][256];
    void createMap(){
        for(int from=0;from<9999;from++){
            for(int to=0;to<256;to++){
                if(to<10||from<1){
                    map[from][to] = ""+to;
                } else if(to==from){
                    map[from][to] = "";
                } else if(to-from==1){
                    map[from][to] = "^";
                } else if(to-from==-1){
                    map[from][to] = "v";
                } else if(to>99){               
                    if(to%from<1){
                        map[from][to] = "*"+(to/from);
                    } else if(to>from&&to-from<10){
                        map[from][to] = "+"+(to-from);
                    } else if(from>to&&from-to<10){
                        map[from][to] = "-"+(from-to);
                    } else {
                        map[from][to] = ""+to;
                    }
                } else {
                    map[from][to] = ""+to;
                }
            }
        }
    }

    String fourierize(String filename) throws Exception{
        StringBuilder out = new StringBuilder();
        byte[] in = Files.readAllBytes(Paths.get(filename));
        String whole = new String(in);
        out.append(in[0] + "a");
        int number = -1;
        for(int i=1;i<in.length;){
            if(in[i]<58&&in[i]>47){
                number = in[i]==48?0:((Number)NumberFormat.getInstance().parse(whole.substring(i,i+4))).intValue();
                out.append(""+number+"o");
                i += (""+number).length();
            } else {
                if(number<0)
                    out.append(map[in[i-1]][in[i]]+"a");
                else
                    out.append(map[number][in[i]]+"a");
                number = -1;
                i++;
            }
        }
        return out.toString();
    }

}

मुझे लगता है कि यह अंकों के तार को अग्रणी शून्य के साथ सही तरीके से नहीं संभालता है। उदाहरण के लिए, इनपुट पर 01, मेरा मानना ​​है कि यह आउटपुट है 01o, जो सही नहीं है।
isaacg

इसके अलावा, मुझे लगता है कि आप संचायक का दुरुपयोग कर रहे हैं। elseमुख्य लूप के खंड में, आप संचायक के वास्तविक मूल्य और पिछले चरित्र के चरित्र मूल्य का उपयोग करने के बीच चयन करते हैं। यदि आप दोनों अलग हैं, तो आप बाद का विकल्प नहीं बना सकते, क्योंकि इसका मतलब है कि आपने oपहले समय का उपयोग किया था, और संचायक में पिछले वर्ण का मान नहीं होता है।
isaacg

ठीक है, अब दोनों को तय किया जाना चाहिए। धन्यवाद!
जियोबिट्स

जब मैं इसे अपने माचिंग पर चलाता हूं, तो मुझे हेमलेट के लिए 625474 और उत्पत्ति के लिए 13705922 मिलता है।
isaacg

@isaacg क्या आप इसे एक ही फाइल (एक ही लाइन एंडिंग के साथ) पर चला रहे हैं? मैं पहले लाइन के अंत के साथ एक समस्या में भाग गया। जब मैं मेरा और तुम्हारा एक ही फाइल पर चलता है, तो वे दोनों पोस्ट किए गए स्कोर दिखाते हैं।
Geobits

2

PHP, 14307118 बाइट्स

601,216 (हेमलेट) + 13,705,902 (बाइबिल)

function f($file) {
    $text = file_get_contents($file);

    $a = 0;

    for ($i = 0; $i < strlen($text); $i++) {
        $chr = $text[$i];

        if (ctype_digit($chr)) {
            while ($chr && isset($text[$i + 1]) && ctype_digit($text[$i + 1])) {
                $chr .= $text[$i + 1];
                $i++;
            }

            if ($a == (int)$chr) {
                print "o";
            }
            else {
                $a = (int)$chr;
                print $chr . "o";
            }

            continue;
        }

        $ord = ord($chr);

        $mapping = array(
            '' => $a,
            '^' => $a + 1,
            'v' => $a - 1
        );

        for ($j = 2; $j <= 9; $j++) {
            $mapping["+$j"] = $a + $j;
            $mapping["-$j"] = $a - $j;
            $mapping["*$j"] = $a * $j;
            $mapping["/$j"] = $a / $j;
        }

        foreach ($mapping as $op => $value) {
            if ($value === $ord) {
                $a = $value;
                print $op . "a";
                continue 2;
            }
            else if ($value . '' === $chr) {
                $a = $value;
                print $op . "o";
                continue 2;
            }
        }

        $a = $ord;
        print $ord . "a";
    }
}

हेमलेट के लिए फूरियर उत्पादन

यह निम्नानुसार काम करता है:

  1. इनपुट में प्रत्येक वर्ण पर Iterates;
  2. यदि नॉन 0 लीडिंग अंकों का अनुक्रम है तो यह संचयकर्ता को उस नंबर पर सेट करेगा और इसे नंबर के रूप में आउटपुट करेगा। यह समान अंकों के लिए भी जांच करता है;
  3. अन्यथा, जांचता है कि 2 और 9 के बीच की संख्या के साथ संचयकर्ता पर एक बुनियादी संचालन (+ - * /) करके वर्तमान चरित्र (एएससीआईआई कोड + "ए" प्रतीक = 4 वर्णों) के बजाय आउटपुट का छोटा तरीका है; जाहिर है, यह भी तुलना / वेतन वृद्धि / गिरावट की कोशिश करता है;
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.