सारंग पुनर्व्यवस्थित

Question

आपका कार्य एक कंप्यूटर प्रोग्राम लिखना है जैसे कि जब इसे लाइनों (नईलाइन वर्ण पर विभाजित) में काट दिया जाता है तो लाइनों की हर व्यवस्था 1 और n के बीच एक अलग संख्या का उत्पादन करेगी ! (जहाँ n कुल पंक्तियों की संख्या है)। कोई भी संख्या दो अलग-अलग व्यवस्थाओं द्वारा आउटपुट नहीं होनी चाहिए और हर व्यवस्था को इस सीमा पर एक संख्या का उत्पादन करना चाहिए। चूँकि वहाँ n हैं! प्रोग्राम की पंक्तियों को व्यवस्थित करने के तरीके इसका मतलब है कि प्रत्येक संख्या को एक पुनर्व्यवस्था द्वारा आउटपुट किया जाना चाहिए।

उदाहरण के लिए अजगर कार्यक्रम

print 1;"""
print 2;"""

दो व्यवस्था है

print 1;"""
print 2;"""

तथा

print 2;"""
print 1;"""

पहला आउटपुट 1और दूसरा आउटपुट 2।

आप जो भी आउटपुट फॉर्मेट मानक भाषा में उपयोग कर रहे हैं, उसका उपयोग कर सकते हैं। आप किसी भी प्रकार के बॉयलरप्लेट को नहीं मान सकते हैं। मुझे लगता है कि यह चुनौती और अधिक दिलचस्प है अगर आपको भाषा पर जोर देने वाले प्रारूप में काम करना है।

स्कोरिंग

आपका स्कोर आपके प्रोग्राम में लाइनों की संख्या होगी, जिसमें उच्च स्कोर बेहतर होगा। यदि आप चाहें तो आप 0 से n- 1 तक आउटपुट संख्या चुन सकते हैं ।

Comments

उन वर्तमान निर्माणों के बारे में क्या जवाब है जो किसी के लिए काम करते हैं n? क्या वे सभी ∞ के स्कोर पर बंधे हैं?

— मार्टिन एंडर

@MartinEnder हां। Score एक अच्छा स्कोर है। यदि आप उस तरह का निर्माण पाते हैं तो आप जीत जाते हैं।

— पोस्ट रॉक गार्फ हंटर

@AdmBorkBork हाँ प्रत्येक व्यवस्था को एक संख्या का उत्पादन करना चाहिए। यह स्पष्ट हो सकता है?

— पोस्ट रॉक गार्फ हंटर

@totallyhuman मानक उत्पादन नियम जो भी भाषा आप उपयोग कर रहे हैं के लिए। मैं इस पर पूरी तरह से स्पष्ट होने के लिए सवाल को अपडेट करूंगा।

— पोस्ट रॉक गार्फ हंटर

@EriktheOutgolfer कोई टाई ब्रेकर नहीं। मार्टिन को सीजेएम में अनंत स्कोर करने का एक तरीका मिल गया है, लेकिन कोशिश करने के लिए अन्य भाषाओं के बहुत सारे हैं।

— पोस्ट रॉक गार्फ हंटर

Answer 1

सीजाम , स्कोर::

प्रत्येक रेखा रूप की है

];Lx+:L{__(f<0+:+\,,(;1+:**\(;}h]:+

जहां xसे एक नंबर है 0करने के लिए n-1। परिणाम सीमा में 0है n!-1।

इसे ऑनलाइन आज़माएं! (के लिए n=3)

उस कोड के लिए jimmy23013 को क्रेडिट जो वास्तविक क्रमचय सूचकांक की गणना करता है। मैंने केवल उस बिट को प्रतिस्थापित किया है ];Lx+:Lजो उस इनपुट को पढ़ता है जिसके साथ पिछली पंक्ति से परिणाम को अलग करता है और फिर वर्तमान लाइन के सूचकांक को चर में जोड़ता है L(जो शुरू में एक खाली सरणी है)।

Comments

ओह, मैंने ऐसा लिखा था। लेकिन यह गोल्फ नहीं दिखता है ... (उदाहरण के लिए 0+:+) मुझे लगता है कि आप एक बहुत छोटे संस्करण का उपयोग कर सकते हैं ,m!#।

— jimmy23013

Answer 2

पर्ल: ∞

$z.="-1,";$_.=A;END{$m.=!!s/./{${z}B}/g,map(/B/||s/\d+\K/,/g*/(-\d*,).*\1/||($n{$_}||=$m++),sort glob),print$n{$z}if/A/}
$z.="-2,";$_.=A;END{$m.=!!s/./{${z}B}/g,map(/B/||s/\d+\K/,/g*/(-\d*,).*\1/||($n{$_}||=$m++),sort glob),print$n{$z}if/A/}
$z.="-3,";$_.=A;END{$m.=!!s/./{${z}B}/g,map(/B/||s/\d+\K/,/g*/(-\d*,).*\1/||($n{$_}||=$m++),sort glob),print$n{$z}if/A/}

अपनी पसंद की किसी भी लंबाई तक बढ़ाएँ

मेमोरी जल्दी से चलेगी क्योंकि मेमोरी उपयोग ओ (n ^ n) की तरह है। हालाँकि, O (n) कोड द्वारा क्रमबद्धता अनुक्रमणिका को प्रतिस्थापित करना आसान होगा। मैं सिर्फ इस तरीके का चित्रण कर रहा हूं जिसका उपयोग आप END{}इस कार्य के लिए पर्ल में कर सकते हैं । सभी END{}ब्लॉक एग्जिट टाइम पर चलते हैं, लेकिन केवल पहले वाले को ही बुलाया जाता है (कोड में एक अंतिम) /A/टेस्ट के कारण कुछ भी आउटपुट करेगा जो केवल एक बार सच होता है

ध्यान दें कि $mकाउंटर को एक स्ट्रिंग के रूप में गिनना चाहिए क्योंकि एक संख्या के रूप में यह अतिप्रवाह होगा (ब्रह्मांड के अंत की तुलना में लेकिन यह वह सिद्धांत है जो गिना जाता है)। उसी कारण से मैं Aवास्तविक काउंटर का उपयोग करने के बजाय एस की एक स्ट्रिंग का निर्माण करके लाइनों की संख्या को "गिनता हूं" हालांकि यह अतिप्रवाह बाद में होगा।

पर्ल में ऐसा करने का एक और तरीका:

@{$b.=A; if($a eq $b) {use bigint; $n=0;$n++for@F;$c=0;$c=$c*$n--+map{$z=$_;$a=grep$_&&$_>$z,@F;$_=0;}@F;print$c}}=()x push@F,"1".!($a.=A),
@{$b.=A; if($a eq $b) {use bigint; $n=0;$n++for@F;$c=0;$c=$c*$n--+map{$z=$_;$a=grep$_&&$_>$z,@F;$_=0;}@F;print$c}}=()x push@F,"2".!($a.=A),
@{$b.=A; if($a eq $b) {use bigint; $n=0;$n++for@F;$c=0;$c=$c*$n--+map{$z=$_;$a=grep$_&&$_>$z,@F;$_=0;}@F;print$c}}=()x push@F,"3".!($a.=A),

यह उस तथ्य का उपयोग करता foo = bar barहै जिसे बाद में निष्पादित किया जाता है foo। वैसे यह संस्करण समय और स्थान में पागल नहीं होता है, लेकिन यह कोड को लंबा बनाता है

फिर भी एक अन्य विचार का उपयोग करना है DESTROYजिसमें यह लाभ है कि उनमें से केवल एक को निष्पादित किया जाएगा। मैं क्रमांकन अनुक्रमण कोड को दोहराने नहीं जा रहा हूं, जिसमें मैंने पहले ही दो उदाहरण दिए हैं।

push@F,"1";bless\@F;DESTROY{print"Work out permutation index of @{$_[0]}\n" }
push@F,"2";bless\@F;DESTROY{print"Work out permutation index of @{$_[0]}\n" }
push@F,"3";bless\@F;DESTROY{print"Work out permutation index of @{$_[0]}\n" }

या उपयोग कर रहा है BEGIN:

BEGIN{push@F,"1"} print"Work out permutation index of @F\n"; exit;
BEGIN{push@F,"2"} print"Work out permutation index of @F\n"; exit;
BEGIN{push@F,"3"} print"Work out permutation index of @F\n"; exit;

Answer 3

जेली , ∞

;3ÇQŒ¿$⁼Q$?
;2ÇQŒ¿$⁼Q$?
;1ÇQŒ¿$⁼Q$?

(उदाहरण के साथ n=3।)

इसे ऑनलाइन आज़माएं!

23 13 11 बाइट्स प्रति पंक्ति।

nलाइनों के साथ एक कार्यक्रम के लिए , लाइनों का प्रारूप होगा

; <i> ÇQŒ¿$⁼Q$?

जहाँ <i>संख्या शाब्दिक है iऔर प्रत्येक पंक्ति में iसे लेकर के लिए एक अलग मान 1है n। ( iवास्तव में इन विशिष्ट संख्याओं के लिए मान नहीं हैं, उनके पास केवल अद्वितीय सकारात्मक मान होना चाहिए।) यह प्रोग्राम अब nलाइन संरचना में उपयोग नहीं करता है।

कैसे?

• एक तर्क के बिना जेली के साथ शुरू होता है 0।
• ;1या सक्रिय सूची में जोड़ता 1है 0।
• ⁼Q$इफ स्टेटमेंट ( ?) के लिए सशर्त मोनाद है जो यह जांचता है कि सूची के तत्व अद्वितीय हैं या नहीं। यदि वे हैं, तो ऊपर दिए गए लिंक को ( Ç) और दूसरे नंबर को सूची में जोड़ा जाता है। यदि वे अद्वितीय नहीं हैं, तो इसका मतलब है कि हमने पहले लिंक के चारों ओर लपेटा है। दोहराया तत्व सूची से हटा दिया जाता है ( Q) और क्रमचय का सूचकांक पाया जाता है ( Œ¿)। ध्यान दें कि 0जब Œ¿लिया जाता है तो सूची की शुरुआत में होता है लेकिन यह आउटपुट को प्रभावित नहीं करता है क्योंकि सभी मान iसकारात्मक होते हैं।

नई जेली सुविधा

नए जोड़े के साथ Ƒत्वरित, हम कम कर सकते हैं ⁼Q$करने के लिए QƑ, एक बाइट की बचत।

10 बाइट्स / लाइन (एकल अंकों के लिए)

;1ÇQŒ¿$QƑ?

इसे ऑनलाइन आज़माएं!

Answer 4

मस्तिष्क-फलक , ३

(({}){})
({}())
(()(){([()()]{})()(){[()()](<{}>)}}{})

इसे ऑनलाइन आज़माएं!

मैंने इसे पहले चैट में पोस्ट किया था लेकिन उम्मीद है कि इसे यहां पोस्ट करके लोग इसका निर्माण कर सकते हैं।

व्याख्या

हम मूल कार्यक्रम से शुरू करते हैं

(({}){})
({}())

यह स्कोर अपने आप में 2 है। अगले स्तर तक कदम बढ़ाने के लिए मैं एक नई लाइन जोड़ना चाहता हूं। मेरा भीख माँगने का अनुमान था

(()(){[()()]{}(<()>)}{})

यह टीओएस सेट करता है 2अगर यह शून्य है और अन्यथा कुछ भी नहीं करता है। यह वास्तव में एक अच्छी शुरुआत है। अन्य दो पंक्तियों के साथ हम सभी संख्याओं 1को 6छोड़कर प्राप्त करने में सक्षम हैं 4, क्योंकि 2आउटपुट के तरीके हैं 2:

({}())
(({}){})
(()(){[()()]{}(<()>)}{})

तथा

({}())
(()(){[()()]{}(<()>)}{})
(({}){})

इस उपाय को करने के लिए हम अपनी रेखा भी बनाते 2हैं 4। इसके साथ किया जा सकता है

(()(){([()()]{})()(){[()()](<{}>)}}{})

स्पष्टता के लिए यह मूल रूप से हास्केल फ़ंक्शन को लागू करता है

f 0 = 2
f 2 = 4
f x = x

यह हमारी समस्या को ठीक करता है क्योंकि जो प्रोग्राम पहले आउटपुट कर रहा था वह 2अब 4किसी अन्य प्रोग्राम को बदलने के साथ आउटपुट करता है।

Answer 5

जावा 7, स्कोर: ∞

public class DerangedRearrangements implements B{public void a(){System.out.println("0");}public static void main(String[]a)throws Exception{java.util.regex.Pattern p=java.util.regex.Pattern.compile("^(?:public )?class ([\\w]+).*");java.io.BufferedReader r=new java.io.BufferedReader(new java.io.FileReader("./DerangedRearrangements.java"));String line; while((line=r.readLine())!=null){java.util.regex.Matcher m=p.matcher(line);if(m.matches()){((B)Class.forName(m.group(1)).getDeclaredConstructor().newInstance()).a();}}}}interface B{void a();}
class b1 implements B{public void a(){System.out.println(getClass().getName().substring(1));}}

इसे ऑनलाइन आज़माएं!

यह 0 से n- 1 तक प्रिंट कर सकता है । अतिरिक्त लाइनें निम्नलिखित प्रारूप की हैं (जहाँ INDEX 1 से n- 1 तक की संख्या है ):

class b<INDEX> implements B{public void a(){System.out.println(getClass().getName().substring(1));}}

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

यह कैसे काम करता है (उच्च स्तर):

अपने स्वयं के स्रोत कोड लाइन द्वारा लाइन पढ़ता है। चूंकि प्रत्येक पंक्ति एक नए वर्ग की घोषणा करती है, इसलिए हम प्रतिबिंब का उपयोग नए वर्ग की एक आवृत्ति बनाने के लिए करते हैं और इसे लागू करने की aविधि है, जिसके लिए यह आवश्यक है क्योंकि यह Bइंटरफ़ेस को लागू करता है।

Answer 6

रूबी , स्कोर: ∞

(a||=[])<<2;a.size<3?0:(p 1+a.sort.permutation.to_a.index(a))
(a||=[])<<1;a.size<3?0:(p 1+a.sort.permutation.to_a.index(a))
(a||=[])<<3;a.size<3?0:(p 1+a.sort.permutation.to_a.index(a))

इसे ऑनलाइन आज़माएं!

इस कार्यक्रम में 61 बाइट्स प्रति पंक्ति (n <10 के लिए) है। इसका डायलेन के समाधान के समान मूल प्रारूप है ; प्रत्येक पंक्ति में पहली संख्या 1और के बीच एक अलग मूल्य होगा n, और प्रत्येक पंक्ति में दूसरी संख्या होगी n।

मैं nकार्यक्रम में शामिल होने से बचने के लिए एक रास्ता खोजने की उम्मीद कर रहा था , लेकिन मुझे एक नहीं मिला।

Answer 7

ब्रेन-फ्लैक , 2 (साथ -d)

{}(@ltN)

इसे ऑनलाइन आज़माएं!

Comments

के लिए 2आप उपयोग कर सकते हैं ({}())और (({}){})।

— पोस्ट रॉक गार्फ हंटर

@WheatWizard विस्तार योग्य प्रारूप बनाने की कोशिश कर रहा है

— क्रिस्टोफर

Answer 8

05AB1E , स्कोर: 1,114,112

0ˆ¯JD{œsk
1ˆ¯JD{œsk
2ˆ¯JD{œsk

इसे ऑनलाइन आज़माएं! 0 अनुक्रमित। प्रत्येक पंक्ति के प्रारंभ में the अलग-अलग वर्णों को वैश्विक सरणी में धकेलता है। अंतिम कोड को छोड़कर बाकी कोड बेकार में निष्पादित किया जाता है, जहां यह एक स्ट्रिंग में मानों को समेटता है, फिर अपना क्रमांकन सूचकांक पाता है। 1,114,112 लेखन के समय संभव यूनिकोड वर्णों की संख्या है (कोड अंक 48-57 पाठ्यक्रम के साथ प्रदर्शित करने के लिए सबसे आसान हैं)।