केवल ऑपरेशन * 3 और / 2 का उपयोग करके किसी भी सकारात्मक पूर्णांक में 1 को परिवर्तित करें

Question

किसी भी सकारात्मक पूर्णांक को 1 से शुरू करके और संचालन के अनुक्रम को लागू करके प्राप्त किया जा सकता है , जिनमें से प्रत्येक "3 से गुणा" या "2 से विभाजित करें, किसी भी शेष को छोड़ दें" ।

उदाहरण (* 3 के लिए लेखन और / 2 के लिए जी):

4 = 1 *3 *3 /2 = 1 ffg
6 = 1 ffggf = 1 fffgg
21 = 1 fffgfgfgggf

निम्नलिखित व्यवहार के साथ एक कार्यक्रम लिखें:

इनपुट : स्टड या हार्ड-कोडेड के माध्यम से कोई भी सकारात्मक पूर्णांक। (यदि हार्ड-कोडित है, तो इनपुट अंक को प्रोग्राम की लंबाई से बाहर रखा जाएगा।)
आउटपुट : f का एक स्ट्रिंग और g का ऐसा <input> = 1 <string>(उदाहरण के रूप में)। रिवर्स ऑर्डर में इस तरह की एक स्ट्रिंग भी स्वीकार्य है। NB: आउटपुट में केवल f और g है, या खाली है।

41 इनपुट होने पर विजेता प्रोग्राम-प्लस-आउटपुट के सबसे कम बाइट्स के साथ प्रविष्टि है ।

Comments

आप कैसे जानते हैं कि यह सच है?

— मारीनस

माना जाता है कि @marinus यह सच है (लेकिन अभी तक साबित नहीं हुआ है)। कुछ सबूत की तलाश में।

— फेबिनआउट

@marinus, आप यह साबित कर सकते हैं कि यह वंश द्वारा संभव है (या मजबूत रूप से प्रेरण द्वारा)। केस-स्प्लिट ऑन x mod 3: यदि x=3yनिर्माण y और फिर लागू होता है f; यदि x=3y+1निर्माण 2y+1और लागू fतो g; यदि x=3y+2तब यह जटिल हो जाता है लेकिन अनिवार्य रूप से पुनरावर्ती है।

— पीटर टेलर

एक अलग नोट पर, क्या आउटपुट आवेदन क्रम में होना चाहिए या रचना क्रम भी स्वीकार्य होगा?

— पीटर टेलर

@PeterTaylor किसी भी तरह से ठीक है।

— Res '

Answer 1

गोल्फस्क्रिप्ट, स्कोर 64 (43-2 + 23)

0{)1.$2base:s{{3*}{2/}if}/41=!}do;s{103^}%+

(41 हार्डकोड है, इसलिए स्कोर के लिए -2 अक्षर)। आउटपुट है

fffgffggffggffgggffgggg

जो २३ अक्षर (बिना न्यूलाइन के) है। निर्माण से कोड गारंटी देता है कि यह हमेशा (सबसे कम) प्रतिनिधित्व करता है।

Comments

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

— दरवाज़े

@Doorknob चुनौती बताती है कि "1 "आउटपुट में शामिल नहीं होना चाहिए।

— हॉवर्ड

Answer 2

हम गंदे हो रहे हैं, दोस्तों!

जावा 210 207 199 वर्ण

public class C{public static void main(String[] a){int i=41;String s="";while(i>1){if(i%3<1){s+="f";i/=3;}else if(i%3<2){s+="g";i+=i+1;}else{s+="g";i+=i+(Math.random()+0.5);}}System.out.println(s);}}

गैर golfed:

public class C {

    public static void main(String[] a) {

        int i = 41;
        String s = "";
        while (i > 1) {
            if (i % 3 == 0) {
                s += "f";
                i /= 3;
            } else {
                if (i % 3 == 1) {
                    s += "g";
                    i += i + 1;
                } else {
                    s += "g";
                    i += i + (Math.random() + 0.5);
                }
            }
        }
        System.out.println(s);
    }
}

आउटपुट: पुराने देवताओं के विश्वास के आधार पर, मेरे पास सबसे छोटा 30 था। ध्यान दें कि आउटपुट को दाईं ओर से पढ़ा जाना चाहिए।

234

1 ggfgfgfgfggfggfgffgfggggfgffgfggfgfggggfgffgfggfgfggfgfggfgfgggggfffgfggfgfggfgfgggffgggggfffgfggggfgffgfggfgfggfgfggfgfggfgfggfgfggfgfggggfgffgfggfgfggfgfggfgfggfgfggfgfggggggggggggfgfgfggggfgfgfggfffgfgfggffgfgfggfgfggggffgfgfffff

108

1 gggffgfgfggggggfggggfgffggggfgfgfgfgfgffgggfgggggfggfffggfgfffffgggffggfgfgggffggfgfgggffggggggfgfgffgfgfff

45 संपादित करें

1 ggfgfgfgfgggfggfffgfggfgfgggggggffgffgfgfff

अंक: 318 199 + 30 = 229

edit1 (2 * i + 1)% 3 == 0 -> (2 * i)% 3 == 1

नोटा बेने अगर आप गोल्फिंग करते समय जावा 6 का उपयोग करते हैं और जावा 7 का नहीं, तो आप उपयोग कर सकते हैं

public class NoMain {
    static {
        //some code
        System.exit(1);
    }
}

एक मानक संरचना के बजाय 39 वर्ण संरचना जो 53 वर्ण लंबी है।

Comments

(2*i+1)%3==0के बराबर हैi%3==1

— हावर्ड

हाँ यही है। धन्यवाद

— फेबिनौट

if(X){A}else{if(Y){B}else{C}}से लंबा है if(X){A}else if(Y){B}else{C}। इसके अलावा, आप अपनी ==शर्तों को छोटी <स्थितियों से बदल सकते हैं।

— पीटर टेलर

@PeterTaylor सच है, मेरा समाधान अभी भी बदसूरत है। मुझे नहीं पता कि क्या यादृच्छिक भाग कोड को छोटा बनाता है, लेकिन यह आउटपुट आउटपुट क्रेपियर बनाता है।

— 12

आपकी f / g स्ट्रिंग्स 'g' से शुरू होती हैं (जो '/ 2' के लिए खड़ा होना चाहिए), इसलिए वे 41 के बजाय 1 से 0 में बदल जाएंगी। f का जी के और इसके विपरीत में बदलना, भी नहीं लगता है 41 दें।

— रिज करें

Answer 3

पायथन, स्कोर 124 (90-2 + ​​36)

x=41;m=f=g=0
while(3**f!=x)*(m!=x):
 f+=1;m=3**f;g=0
 while m>x:m/=2;g+=1
print'f'*f+'g'*g

कोड के 90 चार्ट (प्रत्येक के रूप में 1 अंक) - हार्ड-कोडित इनपुट संख्या + 36 आउटपुट के कोड के लिए 2

आउटपुट:

ffffffffffffffffgggggggggggggggggggg

Comments

यदि आप करते हैं तो m=f=0आप बाहरी लूप बना सकते हैं while(n!=x)*(m!=x)और ब्रेक को हटा सकते हैं । इसे 95 वर्णों के कोड में लाता है।

— डैनियल लुबरोव

@ डैनियल: आप, सर, एक सज्जन और विद्वान हैं। धन्यवाद! आपके प्रस्तुत करने के लिए अभी भी सुरक्षित रूप से 10 चार्ट मेरे आगे है। :)

— डैरेन स्टोन

यदि आप सभी nद्वारा प्रतिस्थापित करते हैं तो आप थोड़ा और बचत कर सकते हैं 3**f।

— हावर्ड

इनपुट = 1 के लिए, आपका प्रोग्राम एक त्रुटि उत्पन्न करता है ("नाम 'जी' परिभाषित नहीं है", बाहरी जबकि-लूप में प्रवेश नहीं करने के कारण)।

— रेस

आप लेखन से एक और चरित्र को काट सकता है print'f'*f+'g'*g, जो 90-2 + 36 = 124 के स्कोर देना होगा

— रेस

Answer 4

पायथन, स्कोर 121 (87 - 2 + 36)

t=bin(41)
l,n,f=len(t),1,0
while bin(n)[:l]!=t:f+=1;n*=3
print(len(bin(n))-l)*'g'+f*'f'

Comments

@ डैरेन, मुझे यकीन नहीं था कि आउटपुट विवरण की व्याख्या कैसे की जाए, लेकिन आप शायद सही हैं। मैंने '1' जोड़ा। धन्यवाद!

— डैनियल लुबरोव

आप '1' (फिर से!) छोड़ सकते हैं आउटपुट विवरण की आपकी मूल व्याख्या सही थी। फिर से पायथन लीड का आनंद लें! :-)

— डैरेन स्टोन

आप अपने 2nd, 3rd, और में 4 लाइनों को सम्मिलित करते हैं l,n,f=len(t),1,0, और हटा दिया '1',प्रिंट बयान से, अपने स्कोर होगा 87-2 + 36 = 121

— रेस

धन्यवाद लोग - मैं गिरा दिया 1,। l,n,f=len(t),1,0वर्णों की एक ही संख्या देता है, है ना? (प्रत्येक चर के लिए, एक =और एक नई ,

— पंक्ति

यदि प्रत्येक नईलाइन एक वर्ण (जैसे UNIX- शैली LF) है, तो एक-पंक्ति और तीन-पंक्ति संस्करणों की लंबाई समान है। यदि प्रत्येक नई पंक्ति दो वर्ण (जैसे MS Windows- शैली CR + LF) है, तो एक-पंक्ति संस्करण तीन-पंक्ति संस्करण से दो वर्ण छोटा है। 121 का स्कोर एक चरित्र की नई कहानियों को मानता है।

— रेस

Answer 5

पर्ल, स्कोर 89 (63 - 2 + 28)

$_=41;$_=${$g=$_%3||$_==21?g:f}?$_*2+$_%3%2:$_/3while$_>print$g

अनुमान: यदि मेरे मूल समाधान में वर्णित भोली दृष्टिकोण कभी किसी चक्र तक पहुंचता है, तो वह चक्र [21, 7, 15, 5, 10, 21, ...] होगा । जैसा कि 1 are n , 10 ^{6 के} लिए कोई काउंटर-उदाहरण नहीं हैं, यह सच होने की संभावना है। यह साबित करने के लिए, यह दिखाना पर्याप्त होगा कि यह एकमात्र चक्र है जोमौजूद हो सकता है, जो मैं बाद के समय में कर सकता हूं या नहीं।

उपरोक्त समाधान अनुमान लगाने (गलत तरीके से) के बजाय तुरंत चक्र से बचा जाता है, और दूसरी बार इसके माध्यम से बचने से।

आउटपुट (28 बाइट्स):

ggfgfgfgfggfggfgfgfggfgfgfff

---

पर्ल, स्कोर 100 (69 - 2 + 33)

$_=41;1while$_>print$s{$_=$$g?$_*2+$_%3%2:$_/3}=$g=$_%3||$s{$_/3}?g:f

एक अनुमान और जांच दृष्टिकोण का उपयोग करना। स्ट्रिंग का उपयोग उलटा ऑपरेशन (मान को 1 में परिवर्तित करने के बजाय, अन्य तरीके से करने के लिए किया जाता है) का निर्माण किया जाता है, और स्ट्रिंग तदनुसार प्रतिबिंबित होती है, जिसे समस्या विनिर्देश द्वारा अनुमति दी जाती है।

जब भी तीन में से एक गैर-एकाधिक का सामना किया जाता है, तो इसे दो से गुणा किया जाएगा, एक को जोड़ना अगर परिणाम तीन में से कई होगा। जब तीन में से कई का सामना किया जाता है, तो इसे तीन से विभाजित किया जाएगा ... जब तक कि यह मान पहले से सामने नहीं आया है, एक चक्र का संकेत देता है, इसलिए अनुमान लगाएं और जांच करें।

आउटपुट (33 बाइट्स):

ggfgfgfgfggfggfgffgfgggfggfgfgfff

Answer 6

जे, स्कोर 103 (82-2 + 23)

* नोट: मैंने अपने क्रियाओं का नाम दिया है fऔर g, आउटपुट स्ट्रिंग्स के साथ भ्रमित होने की नहीं fऔर g।

हार्ड कोडित:

f=:3 :'s=.1 for_a.y do.s=.((<.&-:)`(*&3)@.a)s end.'
'gf'{~#:(>:^:(41&~:@f@#:)^:_)1

सामान्य कार्य:

f=:3 :'s=.1 for_a.y do.s=.((<.&-:)`(*&3)@.a)s end.'
g=:3 :'''gf''{~#:(>:^:(y&~:@f@#:)^:_)1'

बाइनरी नंबरों के ब्लॉक पर काम करना बंद कर दिया, जो कि कॉम्पैक्टिंग के रूप में सबसे महत्वपूर्ण बदलाव था g। चर का नाम बदल दिया और इसके लिए कुछ व्हाट्सएप को हटा दिया, लेकिन सब कुछ अभी भी कार्यात्मक रूप से समान है। (उपयोग: g 41)

जे, स्कोर 197 (174 + 23)

f =: 3 : 0
acc =. 1
for_a. y do. acc =. ((*&3)`(<.&-:)@.a) acc end.
)

g =: 3 : 0
f2 =: f"1 f.
l =. 0$0
i =. 1
while. 0=$(l=.(#~(y&=@:f2))#:i.2^i) do. i=.>:i end.
'fg'{~{.l
)

आउटपुट: ffffffffggggggggfgffggg

fसंख्या में बूलियन्स की एक सूची को परिवर्तित करता है, 0s ​​के रूप में *3और 1s /2(और floor) के रूप में। #:i.2^iएक रैंक 2 सरणी बनाता है जिसमें लंबाई के सभी रैंक 1 बूलियन सरणियों होते हैं i।