ज़ीरो एक मनमाने ढंग से बड़े सेल ब्रेनफ़ में ***

Question

आपका कार्य कोड के एक टुकड़े को लिखना है जो ब्रेनफॉक संस्करण में वर्तमान सेल को शून्य करता है, प्रत्येक सेल में सामान्य 0 से 255 के बजाय, मनमाने ढंग से बड़े परिमाण के एक हस्ताक्षरित पूर्णांक हो सकता है ।

आप देखते हैं यह मान सकते हैं एल कोशिकाओं को छोड़ दिया और करने के लिए आर वर्तमान सेल है कि शुरू में शून्य हैं के अधिकार के लिए कोशिकाओं। आप केवल इन l + r +1 कोशिकाओं तक ही पहुँच सकते हैं। आपके कोड के समाप्त होने के बाद, इसे एल + आर अतिरिक्त कोशिकाओं को शून्य और सूचक को मूल स्थिति में वर्तमान सेल पर छोड़ देना चाहिए ।

आप किसी इनपुट / आउटपुट का उपयोग नहीं कर सकते हैं।

सबसे छोटा l + r वाला कोड जीत जाता है। यदि कोई टाई है, तो सबसे छोटा कोड जीत जाता है। यह संदर्भ के लिए आपके कार्यक्रम की समय जटिलता को भी बताने के लिए अनुशंसित है, जहां n वर्तमान सेल में मूल पूर्णांक का निरपेक्ष मान है।

उपयोगी उपकरण

आप TIO पर mbomb007 द्वारा इस दुभाषिया का उपयोग करके इस भिन्नता में एक ब्रेनफैक कार्यक्रम का परीक्षण कर सकते हैं ।

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

Comments

मैंने इसे कोड-गोल्फ टैग किया है क्योंकि मुझे लगता है कि हम इष्टतम एल + आर तक जल्दी पहुंच जाएंगे।

— jimmy23013

यह आपकी टिप्पणी से लगता है, आपका मतलब बड़े पैमाने पर बड़े पैमाने पर पूर्णांक है, जो सकारात्मक या नकारात्मक हो सकता है। यह कुछ लोगों के लिए अंग्रेजी बोली में अंतर है, इसलिए यह स्पष्ट करने में मददगार हो सकता है कि यह बहुत सकारात्मक या बहुत नकारात्मक हो सकता है।

— ईसैक

@ jimmy23013 क्या आपके पास हस्ताक्षरित कोशिकाओं के साथ एक बीएफ दुभाषिया है जो हम इसके लिए उपयोग कर सकते हैं?

— mbomb007

@ mbomb007 codegolf.stackexchange.com/a/3085/25180 लेकिन शायद बहुत गोल्फ ...

— jimmy23013

@ क्यों? "वास्तविक" चुनौती में, आपको इष्टतम एल + आर भी प्राप्त करना होगा, जो कोड आकार को कम करने के लिए संभवतः अधिक कठिन बना देगा।

— jimmy23013

Answer 1

l + r = 0 + 2 = 2, 55 53 51 बाइट्स

[>+[-<+>>+<]<[>]>[+[-<+<->>]<[->+<]]>[-<+>]<<]>[-]<

l + r = 1 + 2 = 3, 46 44 बाइट्स

[[>+[-<+<+>>]<[<+[->->+<<]]>]>[>]<[-]<<[-]>]

मेरा अपना एल्गोरिथ्म। सूचक को उस संख्या पर शुरू करना चाहिए जिसे शून्य करने की आवश्यकता है। समय जटिलता O (n ^ 2) है।

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

• हम संख्या के साथ शुरू करते हैं n।
• हम एक वृद्धि करते हैं, इसलिए संख्या बन जाती है n+1।
• हम दो घटाते हैं, इसलिए संख्या बन जाती है n+1-2 = n-1
• हम तीन वेतन वृद्धि करते हैं, इसलिए संख्या बन जाती है n-1+3 = n+2।
• हम चार घटाते हैं, इसलिए संख्या बन जाती है n+2-4 = n-2।

हम प्रक्रिया को दोहराते हैं, प्रत्येक चरण को बढ़ाते हैं, जब तक कि हम शून्य नहीं हो जाते।

Comments

सटीक रूप से एल्गोरिथ्म के बाद मैंने सोचा कि मुझे "यह भी संभव नहीं है" मंच से

— आगे बढ़ने के बाद

Answer 2

l + r = 0 + 2 = 2; 58 बाइट्स

>+<[>[<->>+<-]>+<<[>]>[<<+>+>-]<[->+<]>[<]>+[-<+>]<<]>[-]<

जटिलता हे (n ^ 2)।

निम्नलिखित मेरा परीक्षण कार्यक्रम जनरेटर है, इसलिए आप देख सकते हैं कि मैंने वास्तव में यह परीक्षण करने की कोशिश की है कि यह काम नहीं करता है ...

p='''
>+<
[
>
[<->>+<-]
>+<
<[>]>
[<<+>+>-]
<
[->+<]
>[<]>
+ [-<+>]
<<
]
> [-] <
'''

p = ''.join(p.split())

cpp = '''
#include <bits/stdc++.h>
using namespace std;
void test(int q) {
long long t[3] = {q, 0, 0};
int i = 0;
ZZZ
printf("q=%d %lld %lld %lld\\n", q, t[0], t[1], t[2]);
}
int main() {
while(true) {
    int q; cin >> q; test(q);
}
}
'''

d = {
'>': '++i; assert(i<3);',
'<': '--i; assert(i>=0);',
'+': '++t[i];',
'-': '--t[i];',
'[': 'while(t[i]){',
']': '}',
}

print cpp.replace('ZZZ', ''.join(d[c] for c in p))

Comments

आप इसे सिर्फ मेरे द्वारा बनाए गए दुभाषिए का उपयोग करके देख सकते हैं। टिप्पणी देखें

— mbomb007

ऐसा लग रहा है कि यह मेरे लिए काम करता है।

— mbomb007

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

@ ais523 अन्य समकक्ष हो सकते हैं। यदि कोई व्यक्ति l + r = 1 + 1 बनाता है तो यह दिलचस्प होगा।

— mbomb007