कैसे पृथ्वी पर Pyhui के 42 बाइट्स में ईविल नंबर का उत्पादन करूँगा?

Question

यह पाइथन में गोल्फ के लिए एक टिप्‍पणी प्रश्‍न है, जो एनार्की गोल्‍फ पर ईविल नंबरों के प्रश्‍न के विषय में है ।

यदि बाइनरी विस्तार में 1 की संख्या है, तो एक संख्या बुराई है । चुनौती पहले 400 बुराई संख्याओं को मुद्रित करने की है 0,3,5,...,795,797,798, प्रति पंक्ति एक।

पायथन 2 प्रस्तुतियाँ 42-बाइट समाधान के साथ llhuii के नेतृत्व में हैं। अगला सबसे अच्छा है 46 बाइट्स मिच द्वारा, उसके बाद पांच 47-बाइट सबमिशन। ऐसा लगता है कि विहुई ने वास्तव में कुछ जादुई पाया है जिसने 2 वर्षों में कई मजबूत पायथन गोल्फरों को बाहर कर दिया है। इतने छोटे गोल्फ के लिए 4 या 5 बाइट्स की बचत बहुत बड़ी है।

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

हालांकि प्रस्तुतियाँ सामने नहीं आई हैं क्योंकि यह समस्या अंतहीन है, हमें कुछ लीड दिए गए हैं। जीतने की सबमिशन को चलाने में 0.1699 सेकंड का समय लगा, जो कि किसी अन्य की तुलना में अधिक लंबा है, जो एक अयोग्य विधि का सुझाव देता है। बाइट आंकड़ों से, 42 वर्णों में से, 23 अल्फ़ान्यूमेरिक हैं [0-9A-Za-z]और 19 ASCII प्रतीक हैं। इसका मतलब यह है कि llhuii के समाधान में कोई व्हाट्सएप नहीं है।

आप समस्या पृष्ठ पर अपने कोड का परीक्षण कर सकते हैं , भाषा छोड़ने या .pyफ़ाइल अपलोड करने से पायथन का चयन कर सकते हैं । ध्यान दें कि:

• पायथन 2.7 का उपयोग किया जाता है
• आपका कोड एक पूर्ण प्रोग्राम होना चाहिए जो प्रिंट करता है
• इस समस्या के लिए कोई इनपुट नहीं है, जैसे कि कोलमोगोरोव-जटिलता
• आपके कार्यक्रम को केवल दिए गए 400 मानों को प्रिंट करना है, भले ही यह बड़े मूल्यों पर टूट जाए
• प्रोग्राम को चलाने के लिए 2 सेकंड हैं
• कार्यक्रम त्रुटि के साथ समाप्त हो सकते हैं
• आप उपयोग कर सकते हैं exec; "निष्पादन से वंचित है" शेल निष्पादन को संदर्भित करता है

Comments

यह भी ध्यान देने योग्य बात हो सकती है कि यह क्रम "थ्यू-मोर्स सीक्वेंस इन ए010160" में शून्य का संकेत है। (स्रोत: oeis )

— कॉनर ओ'ब्रायन

Answer 1

यह llhuii के रूप में एक ही समाधान नहीं है, लेकिन यह भी 42 बाइट्स लंबा है।

n=0;exec'print n;n^=(n^n+2)%3/2;n+=2;'*400

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

@JonathanFrech की बदौलत अब हम 40 बाइट्स पर हैं।

n=0;exec'print n;n=n+2^(n^n+2)/2%3;'*400

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

कुल 39 के लिए एक और बाइट बचाई जानी है।

n=0;exec'print n;n=n+2^-(n^n+2)%3;'*400

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

Comments

जिज्ञासा से बाहर, आप कैसे जानते हैं कि 42-बाइट संस्करण llhuii के समान नहीं है? (मैंने अनार्की गोल्फ में कभी भाग नहीं लिया है)

— लुइस मेंडू

@LuisMendo सांख्यिकी टैब में 23 अल्फ़ान्यूमेरिक बाइट्स और 19 ASCII प्रतीकों को सूचीबद्ध किया गया है, इसलिए कोई व्हाट्सएप नहीं है। जब तक llhuii ने लिखा print+n, उनका समाधान खदान से अलग होना चाहिए।

— डेनिस

आह, तो आप कुछ जानकारी प्राप्त कर सकते हैं भले ही आपको कोड न पता हो। वह अच्छा हैं। धन्यवाद!

— लुइस मेंडो

क्या आपको लगता है कि 38 का मौका है? सिद्धांत रूप में, कुछ हद तक -साथ print~nया print-nउपयोग करके &या हटाकर संकेत को हटाने की स्वतंत्रता की कुछ डिग्री हैं ~, हालांकि मैंने काम करने के लिए कुछ भी प्राप्त नहीं किया है। इसके अलावा, n=0;exec"print n;d=n^n+2;n^=d^-d%3;"*400सुंदर है, लेकिन 40 बाइट्स।

— 2

print-nलगता है की संभावना नहीं है क्योंकि वहाँ के बिट्स के बीच कोई आसान रिश्ता नहीं है nऔर -n। print~nसिद्धांत में अधिक आशाजनक लगता है, लेकिन मैं इस दृष्टिकोण के साथ 40 बाइट्स से नीचे नहीं जा सकता।

— डेनिस

Answer 2

39 बाइट्स हो रही हैं

यह एक विवरण है कि मुझे 39-बाइट समाधान कैसे मिला, जो डेनिस और जोनाथनफ्र्रेच ने अलग-अलग पाया। या, बल्कि, यह बताता है कि कोई व्यक्ति उत्तर में कैसे पहुंच सकता है, एक तरह से यह मेरे वास्तविक मार्ग की तुलना में बहुत अच्छा है, जो कीचड़ युक्त तर्क और मृत सिरों से भरा था।

n=0
exec"print n;n=n+2^-(n+2^n)%3;"*400

यह थोड़ा कम गोल्फ और अधिक parens के साथ लेखन, यह इस तरह दिखता है:

n=0
for _ in range(400):
  print n
  n=(n+2)^(-((n+2)^n))%3

बिट समानताएँ

हम अपने 47-बाइट समाधान से एक विचार के साथ शुरू करते हैं कि फॉर्म के सभी नंबरों को आउटपुट करने के लिए n=2*k+bजहां kगिनती होती है 0,1,...,399और bएक समता बिट है जो समग्र संख्या 1 को भी बनाता है।

par(x)की बिट समता के लिए लिखते हैं x, कि ^सभी में बिट्स का xor ( ) है x। यह 0 है यदि 1-बिट्स की संख्या समान है (संख्या बुराई है), और यदि 1-बिट्स की विषम संख्या है। इसके लिए n=2*k+b, हमारे पास par(n) = par(k)^bबुराई को प्राप्त करने की par(n)==0आवश्यकता है b=par(k), अर्थात nपूर्ववर्ती बिट्स की थोड़ी समानता होना।

गोल्फ में मेरी पहली प्रयासों को व्यक्त करने पर थे par(k), पहले सीधे पर साथ bin(k).count('1')%2साथ, और फिर थोड़ा हेरफेर ।

समता अद्यतन

फिर भी, एक छोटी अभिव्यक्ति प्रतीत नहीं हुई। इसके बजाय, यह महसूस करने में मदद मिली कि काम करने के लिए अधिक जानकारी है। वर्तमान संख्या की बिट समता की गणना करने के बजाय,

k  ---->  par(k)

जैसे ही हम वृद्धि kकरते हैं हम बिट समता को अपडेट कर सकते हैं k+1।

k   ---->  par(k)
      |
      v
k+1 ---->  par(k+1)

यही है, जब से हम गिनती कर रहे हैं k=0,1,2,..., हमें केवल हर बार खरोंच से गणना करने के बजाय वर्तमान बिट समता बनाए रखने की आवश्यकता है। बिट समता अद्यतन par(k+1)^par(k)बिट्स की संख्या की समता है जिसमें से जाने में फ़्लिप किया kजाता है k+1, अर्थात par((k+1)^k)।

par(k+1) ^ par(k) = par((k+1)^k)
par(k+1) = par(k) ^ par((k+1)^k)

के प्रपत्र (k+1)^k

अब हमें गणना करने की आवश्यकता है par((k+1)^k)। ऐसा लग सकता है कि हम कहीं नहीं गए हैं क्योंकि कंप्यूटिंग बिट समता वास्तव में समस्या है जिसे हम हल करने की कोशिश कर रहे हैं। लेकिन, संख्याओं के रूप में व्यक्त (k+1)^kकिया गया है 1,3,7,15,.., जो कि 2 की शक्ति से नीचे है, एक तथ्य जो अक्सर बिट हैक्स में उपयोग किया जाता है । आइए देखते हैं कि ऐसा क्यों है।

जब हम वृद्धि करते हैं k, तो बाइनरी कैरीज़ का प्रभाव अंतिम 0और सभी 1को अपने अधिकार में लाना है, 0अगर कोई नहीं था तो एक नया अग्रणी बनाता है। उदाहरण के लिए, ले लोk=43=0b101011

      **
  101011  (43)
 +     1
  ------
= 101100  (44)

  101011  (43)
 ^101100  (44)
  ------
= 000111  (77)   

एक ले जाने वाले कॉलम के साथ चिह्नित हैं *। इनमें एक 1बदलाव होता है 0और कैरी बिट पर गुजरता है 1, जो बाईं ओर प्रचारित करता रहता है जब तक कि यह एक हिट नहीं हो 0जाता k, जो बदल जाता है 1। बाईं ओर आगे कोई भी बिट अप्रभावित है। तो, जब k^(k+1)जाँच करता है जो थोड़ा अपनी जगह बदल kकरने के लिए k+1, यह सबसे दायीं ओर की स्थिति पाता है 0और 1अपने अधिकार के लिए की। यही है, बदले हुए बिट्स एक प्रत्यय बनाते हैं, इसलिए परिणाम 0 होता है और उसके बाद 1 या उससे अधिक होता है। अग्रणी शून्य के बिना, द्विआधारी संख्याएं 1, 11, 111, 1111, ...हैं जो 2 की शक्ति से नीचे हैं।

कम्प्यूटिंग par((k+1)^k)

अब जब हम समझते हैं कि (k+1)^kयह सीमित है 1,3,7,15,..., तो आइए ऐसी संख्याओं की बिट समता की गणना करने का एक तरीका खोजें। यहाँ, एक उपयोगी तथ्य यह है कि 1,2,4,8,16,...वैकल्पिक मोडुलो और के 3बीच , तब से । तो, ले जा सापेक्ष देता है , वास्तव में अपने बिट parities होते हैं। उत्तम!122==-1 mod 31,3,7,15,31,63...31,0,1,0,1,0...

तो, हम अद्यतन के par(k+1) = par(k) ^ par((k+1)^k)रूप में कर सकते हैं

par(k+1) = par(k) ^ ((k+1)^k)%3

bजिस वेरिएबल को हम समता में संचित कर रहे हैं, उसका उपयोग करके यह दिखता है

b^=((k+1)^k)%3

कोड लिखना

इसे एक साथ कोड में डालते हुए, हम शुरू करते हैं kऔर समता bदोनों पर 0, फिर बार-बार प्रिंट n=2*k+bऔर अपडेट करते हैं b=b^((k+1)^k)%3और k=k+1।

46 बाइट्स

k=b=0
exec"print 2*k+b;b^=(k+1^k)%3;k+=1;"*400

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

हम चारों ओर कोष्ठक हटाया k+1में ((k+1)^k)%3क्योंकि अजगर पूर्वता पहले वैसे भी, अजीब के रूप में यह लग रहा है इसके अलावा करता है।

कोड में सुधार

हम एक एकल चर के साथ सीधे काम करके n=2*k+bऔर उस पर सीधे अपडेट करके बेहतर प्रदर्शन कर सकते हैं। करने से k+=1मेल खाती है n+=2। और, अद्यतन करने से b^=(k+1^k)%3मेल खाती है n^=(k+1^k)%3। यहां, k=n/2अपडेट करने से पहले n।

44 बाइट्स

n=0
exec"print n;n^=(n/2+1^n/2)%3;n+=2;"*400

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

हम पुनर्लेखन करके n/2+1^n/2इसे (याद कर सकते हैं) छोटा कर सकते हैं(n/2+1)^n/2

n/2+1 ^ n/2
(n+2)/2 ^ n/2
(n+2 ^ n)/2    

चूंकि /2अंतिम बिट को हटाता है, इससे कोई फर्क नहीं पड़ता कि हम इसे एक्सर-इन के पहले या बाद में करते हैं। तो, हमारे पास है n^=(n+2^n)/2%3। हम उस मोडुलो को ध्यान में रखते हुए एक और बाइट को बचा सकते हैं 3, /2इसके *2बराबर है -, यह देखते हुए कि n+2^nविभाजन के बिना फर्श के साथ वास्तविक विभाजन है। यह देता हैn^=-(n+2^n)%3

41 बाइट्स

n=0
exec"print n;n^=-(n+2^n)%3;n+=2;"*400

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

अंत में, हम संचालन n^=c;n+=2को एक में जोड़ सकते हैं n=(n+2)^c, जहां cथोड़ा सा है। यह काम करता है क्योंकि ^cकेवल अंतिम बिट पर कार्य +2करता है और अंतिम बिट के बारे में परवाह नहीं करता है, इसलिए संचालन शुरू होता है। फिर से, पूर्वता हमें परेंस को लिखने और लिखने से रोकता है n=n+2^c।

39 बाइट्स

n=0
exec"print n;n=n+2^-(n+2^n)%3;"*400

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

Answer 3

यह मेरा (xnor का) 47-बाइट सॉल्यूशन देता है और वह सोच जिसने मुझे इसके लिए प्रेरित किया। यदि आप यह जानना चाहते हैं तो इसे न पढ़ें।

एक प्राकृतिक पहला विचार 0 से 799 की संख्या के माध्यम से पुनरावृत्त करना है, केवल उन लोगों को मुद्रित करना जो बाइनरी में 1 की संख्या के साथ हैं।

52 बाइट्स

for n in range(800):
 if~bin(n).count('1')%2:print n

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

यहाँ, गणना में ~स्विच करने के लिए थोड़ा पूरक लेता है even<->oddऔर केवल गिनती पर भी एक सत्य मूल्य देता है।

हम फ़िल्टर करने के बजाय सभी मान उत्पन्न करके इस पद्धति को बेहतर बना सकते हैं। ध्यान दें कि आउटपुट मान 0 से 399 की संख्या है, प्रत्येक को थोड़ा सा जोड़कर 1 बिट की संख्या भी बनाने की आवश्यकता है।

0 = 2*0 + 0
3 = 2*1 + 1
5 = 2*2 + 1
6 = 2*3 + 0
...

तो, nवें नंबर या तो 2*n+bसाथ है b=0या b=1। बिट को बिट्स में गिनकर और मोडुलो 2 की गिनती bकरके पाया जा सकता है ।1n

49 बाइट्स

for n in range(400):print 2*n+bin(n).count('1')%2

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

हम 2 बाइट्स को इससे 2*अधिक पुनरावृत्ति करके काट सकते हैं 0,2,4,..., जो कि गिनती की संभावना नहीं रखता है 1। हम एक execलूप का उपयोग करके ऐसा कर सकते हैं जो 400 बार चलता है और n2 प्रत्येक लूप से बढ़ रहा है।

47 बाइट्स

n=0;exec"print n+bin(n).count('1')%2;n+=2;"*400

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

और, यह मेरा 47-बाइट समाधान है। मुझे सबसे अधिक संदेह है कि सभी अन्य 47-बाइट समाधान समान नहीं हैं।

Comments

क्या आपके 47 बाइट्स लंबे- execबैप्रोच की अनुमति है?

— जोनाथन फ्रेच

@JonathanFrech हाँ, जब पृष्ठ कहता है कि "निष्पादन से वंचित किया गया है", यह पायथन की नहीं execबल्कि कमांड लाइन का जिक्र है exec।

— xnor

Answer 4

llhuii के पायथन 3 प्रस्तुत

लेखन के समय ईविल नंबरों के लिए पायथन 3 प्रस्तुतियाँ इस प्रकार हैं:

llhuii ने शायद पायथन 3 के लिए अपनी चाल को चित्रित किया, और एक समाधान के साथ आया

• उनके पायथन 2 समाधान की तुलना में 3 बाइट्स लंबे समय तक, और
• 45 - (25 + 18) = 2 व्हाट्सएप के बाइट्स।

पोर्टिंग एक्सनोर के 47B को पायथन 3 में शाब्दिक रूप से, हमें यह 50B मिलता है:

n=0;exec("print(n+bin(n).count('1')%2);n+=2;"*400)

मैंने इसे प्रस्तुत किया ppcg(xnor)। (यह कोष्ठक जोड़ता है execऔर print, जो अब कार्य कर रहे हैं।) इसमें अन्य पायथन 3 उत्तरों के अलग-अलग कोड आँकड़े हैं, जिनमें से सभी में व्हॉट्सएप की कुछ मात्रा है। दिलचस्प!

हालांकि इसे फिर से लिखने का एक छोटा तरीका है ( execपायथन 3 में अपनी प्रतिस्पर्धात्मक बढ़त खोना)

n=0
while n<800:print(n+bin(n).count('1')%2);n+=2

यह 49 बाइट्स है। मैंने इसे प्रस्तुत किया ppcg(xnor,alternative)। यह व्हॉट्सएप के जवाब की तरह व्हॉट्सएप के दो बाइट्स है! यह मुझे विश्वास दिलाता है कि llhuii के Python 3 का उत्तर इस तरह दिखता है (newline, फिर एक whileलूप।) तो ll llhuii शायद execPython 2 में और whilePython 3 में, हमारे जैसे ही उपयोग किया जाता है; यह व्हॉट्सएप विसंगति के बारे में बताता है।

---

हमारा 47B पायथन में 49B बन गया। 3. अब क्या दिलचस्प है, यह है कि llhuii के 42B 44B नहीं बने, यह 45B बन गया! Llhuii के समाधान के बारे में कुछ अजगर 3 में एक बाइट अतिरिक्त लेता है। इसका मतलब विभिन्न प्रकार की चीजें हो सकता है।

• पहली बात जो दिमाग में आती है वह है विभाजन : शायद /पायथॉन 2 में llhuii का उपयोग करता है, जो //कि पायथन 3 में बन गया है (यदि वे हमारी तरह दोहों में गिने जा रहे हैं, तो एक बिट द्वारा दाईं ओर वापस n/2स्थानांतरित करने के लिए उपयोग किया जा सकता है n?)

• दूसरी बात जो मन में आती है वह प्रिंट के बाद एकरी संचालकों की है । हमारा (1 बाइट अतिरिक्त) print blahबन गया print(blah), लेकिन अगर विहुई ने print~-blahपायथन 2 में कुछ लिखा , तो वह print(~-blah)पायथन 3 में बन जाएगा ।

• शायद अन्य विचार हैं। कृपया मुझे बताओ।

अब सहित सभी Py3 समाधानों के लिए कोड आँकड़े:

Comments

मुझे जो दिलचस्प लगा वह यह है कि उनका पायथन 3 समाधान उनके पायथन 2 समाधान की तुलना में काफी तेज है। या तो वे कुछ पायथन सुविधा का उपयोग कर रहे हैं, जो पायथन 3 में अधिक कुशल है या यह सब के बाद एक साधारण पोर्ट नहीं है (हो सकता है कि उन्हें पायथन 3 समाधान मिला था जो कि प्रत्यक्ष पोर्ट से कम है)।

— जोनाथन फ्रीच

एनागोल पर रनटाइम्स का बहुत बड़ा विचलन है, मैंने ओपी पर टिप्पणी की कि यहां विहुई का रनटाइम मुझे लगता है कि उनका Py2 रनटाइम सिर्फ एक लाल हेरिंग / आउटलाइन है

— लिन

इसके अलावा, मुझे लगता है XNOR एक बहुत ही इसी तरह की चाल मिल गया है और (वहाँ नहीं हो सकता इस पर सुधार हुआ है कि बहुत सारे बुरे संख्या मुद्रित करने के लिए तरीके हैं, सही ?!) और उनके समाधान बहुत तेज है!

— लिन

Answer 5

अन्य दृष्टिकोण

1) A001969 के लिए एक सूत्र का उपयोग करना

बाइनरी में कनवर्ट करने के बजाय, निम्न सूत्र ( OEIS से ) का लाभ उठाना संभव हो सकता है :

a(1) = 0
for n > 1: a(n) = 3*n-3-a(n/2) if n is even
           a(n) = a((n+1)/2)+n-1 if n is odd

मैं पायथन में गोल्फिंग में बहुत खराब हूं, इसलिए मैं कोशिश करने वाला भी नहीं हूं। लेकिन यहाँ जेएस में एक त्वरित प्रयास है।

^{NB: मुझे नहीं लगता कि यह एक वैध JS सबमिशन होगा क्योंकि यह केवल एक सरणी को प्रदर्शित किए बिना भर रहा है। और फिर भी, यह वर्तमान सबसे अच्छा जेएस समाधान (जो 45 बाइट्स है) की तुलना में 5 बाइट्स लंबा है। लेकिन वैसे भी यहाँ बात नहीं है।}

for(a=[n=0,3];n<199;)a.push(2*++n+a[n],6*n+3-a[n])

for(a=[n=0,3];n<199;)a.push(2*++n+a[n],6*n+3-a[n])

console.log(a.join`, `)

उम्मीद है कि यह कुछ प्रेरणा दे सकता है।

एक सरणी का उपयोग करना शायद एक अच्छा विचार नहीं है क्योंकि इसे आरंभीकृत और अद्यतन करने की आवश्यकता है। इसके बजाय एक पुनरावर्ती फ़ंक्शन का उपयोग करना अधिक कुशल (कोड आकार बुद्धिमान) हो सकता है , जो बताता है कि क्यों जीतने वाला समाधान अन्य लोगों की तुलना में अधिक समय ले रहा है।

2) प्रतिस्थापन के साथ थ्यू-मोर्स अनुक्रम का निर्माण

सिद्धांत रूप में, इस कोड को काम करना चाहिए:

n=0;a="1";b="0";exec"t=a;a+=b;b+=t;print(int(b[n]))+n;n+=2;"*400

इसे ऑनलाइन आज़माएं! (रन करने योग्य संस्करण 20 शब्दों तक सीमित)

यह लगातार प्रतिस्थापन के साथ थ्यू-मोर्स अनुक्रम की गणना करता है और एक ही लूप में 1 (एविल नंबर) की स्थिति की तलाश करता है।

परंतु:

• यह अपने वर्तमान स्वरूप में बहुत लंबा है
• यह जल्दी से एक स्मृति अतिप्रवाह की ओर जाता है

3) बिटवे ऑपरेशन के साथ थ्यू-मोर्स अनुक्रम का निर्माण

थ्यू-मोर्स अनुक्रम की विकिपीडिया की प्रत्यक्ष परिभाषा से शुरू करते हुए , मैं इस एल्गोरिथ्म में आया हूं (जेएस पर वापस लौटकर ... क्षमा करें):

for(e=n=0;n<799;)(e^=!(((x=n++^n)^x/2)&170))||console.log(n)

जहां हम ई में अनुक्रम की वर्तमान दुष्टता का ट्रैक रखते हैं और एक बाइट में विषम बिट्स के बिटकैम के रूप में 170 का उपयोग करते हैं ।

Comments

मैं एक पुनरावर्ती कार्य के विचार को पसंद करता हूं, लेकिन बॉयलरप्लेट के लिए पायथन बहुत खराब है: f=lambda n:_ for n in range(400):print f(n)पहले से ही 43 बाइट्स लेता है। हो सकता है कि एक सरणी का निर्माण करने के लिए पुनरावृत्ति का अनुकरण करने का एक तरीका है जो स्वयं को संदर्भित करता है, या एक ऐसा सरणी जो भविष्य के तत्वों को अंत तक जोड़ता है।

— xnor

इसके अलावा, llhuii के समाधान, उस में कोई रिक्त स्थान है तो वह उपयोग नहीं किया def, for, while, lambda(एक पैरामीटर के साथ कम से कम), आदि

— स्टीफन

@ स्टेफेन कुछ ऐसा है जिसे while~0:print~1किसी स्थान की आवश्यकता नहीं है।

— जोनाथन फ्रेच

विधि संख्या 3 में, ((x=n++^n)^x/2)सबसे कम सेट बिट को खोजने के लिए कुछ शब्दशः लगता है। उस पूरी गंदगी को बदला जा सकता है ++n&-n। इसे ऑनलाइन आज़माएं!

— प्रिमो

@primo मुझे पता नहीं है कि मैं यहाँ क्या सोच रहा था और मैं इस बोझिल सूत्र में कैसे आया। ¯ \ _ (ツ) _ / ¯

— अर्नुलद

Answer 6

नेस्टेड काउंटर दृष्टिकोण

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

अपुष्ट विचार:

n=0
i=1
for _ in"01":
 i^=1
 for _ in"01":
  i^=1
  for _ in"01":
   i^=1
   for _ in"01":
    i^=1
    for _ in"01":
     i^=1
     for _ in"01":
      i^=1
      for _ in"01":
       i^=1
       for _ in"01":
        i^=1
        for _ in"01":
          i^=1
          if n<800:print i+n
          n+=2

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

गहराई तक घोंसला बनाने वाले नौ स्तर, सभी छोरें समान हैं, इसलिए मेरे दिमाग में उन्हें बनाया जाना चाहिए exec"something"*9+"deepest stuff"। अभ्यास में मुझे नहीं पता कि क्या यह चक्र के साथ ऐसा कुछ करना संभव है।

गोल्फ के लिए विचार करने योग्य बातें:

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

• वहाँ भी एक बेहतर विकल्प हो सकता है if n<800:, जो यहाँ की जरूरत है क्योंकि अन्यथा हम 2 ^ 10 तक की बुराई संख्याओं को प्रिंट करते रहेंगे

Comments

116 बाइट्स ।

— जोनाथन फ्रेच

शायद छोरों के लिए नेस्टेड के बजाय नेस्टेड सूची की समझ की कोशिश करें?

— स्पर

@Srr समस्या तब वास्तव में संख्याओं को प्रिंट करने के लिए है। पायथन 2 में, printएक कथन है, एक फ़ंक्शन नहीं है, और इस प्रकार एक समझ के अंदर प्रकट नहीं हो सकता है।

— जोनाथन फ्रेच

हो सकता हैprint '\n'.join([[[[[[[[[foo]foo]foo]foo]foo]foo]foo]foo]foo])

— शपथ

@Srr तब समस्या सूची को समतल करने में निहित है; str.joinकेवल स्ट्रिंग्स वाले सूचियों पर काम करता है और अतिरिक्त सूची वर्णों को मुद्रित नहीं किया जाना चाहिए। अकेले फॉर्मेट करने से महत्वपूर्ण मात्रा में बाइट्स होते हैं।

— जोनाथन फ्रीच

Answer 7

विचार: छोटा सा समता

bin(n).count('1')%2बिट-काउंट की समता की गणना करने के लिए इसे करने के लिए कई पात्र लगते हैं । शायद एक अंकगणितीय तरीका छोटा है, विशेष रूप से एक सीमित बिट लंबाई।

एक प्यारा समान-लंबाई तरीका है int(bin(n)[2:],3)%2, बाइनरी मान को आधार 3(या किसी भी विषम आधार) की व्याख्या करना । दुर्भाग्य से, 4 बाइट्स 0bउपसर्ग को हटाने में खर्च होते हैं । यह करने के लिए भी काम करता है int(bin(n)[2:])%9%2।

एक और विचार एक्सर्स का उपयोग करके बिट्स के संयोजन से आता है। यदि nबाइनरी प्रतिनिधित्व है abcdefghi, तो

n/16 = abcde
n%16 =  fghi

r = n/16 ^ n%16 has binary representation (a)(b^f)(c^g)(d^h)(e^i)

तो, r=n/16^n%16बुराई है अगर और केवल अगर nबुराई है। हम तो दोहरा सकते हैं के रूप में है कि s=r/4^r%4, एक मूल्य sमें 0,1,2,3हैं, जिनमें से 1और 2बुराई, साथ चेक करने योग्य नहीं हैं 0<s<3।

52 बाइट्स

n=0;exec"r=n/16^n%16;print(0<r/4^r%4<3)+n;n+=2;"*400

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

यह एक अच्छा सौदा निकला। संख्या को कैसे विभाजित किया जाए, अंतिम संख्या की जांच कैसे की जाए (शायद एक बिट-आधारित लुकअप तालिका)। मुझे संदेह है कि ये केवल इतनी दूर जा सकते हैं।

Comments

क्या यह to_bytesपूर्णांकों के कार्य का उपयोग करने की संभावना होगी ? मुझे संदेह है लेकिन इस पर विचार करने के लिए कुछ :)

— हाइपरनेट्रोइनो

@ हायपरनेटिनो मुझे लगता है कि पायथन 3 ही है?

— xnor

हाँ मेरी ख़राब: / चीर

— HyperNeutrino

सीधे शब्दों में उपयोग करें 0b: int(bin(n),13)%2! : D

— Noodle9

प्रगति! नूडल 9 की चाल 44-बाइट समाधान प्रदान करती है:n=0;exec"print~int(bin(n),13)%2+n;n+=2;"*400

— लिन

Answer 8

निर्माण से, n+n^nहमेशा बुराई होती है, लेकिन मेरे गरीब पायथन कौशल केवल 61-बाइट समाधान के साथ आ सकते हैं:

for n in sorted(map(lambda n:n+n^n,range(512)))[:400]:print n

5 बाइट बचाने के लिए @Peilonrayz और 1 बाइट बचाने के लिए @ Mr.Xcoder का धन्यवाद:

for n in sorted(n^n*2for n in range(512))[:400]:print n

Comments

55 बाइट्स : for n in sorted(n^n*2for n in range(512))[:400]:print n। n+n^nके रूप में ही हैn^n*2

— श्री Xcoder

Answer 9

आइडिया: A006068 ("ए (एन) ग्रे-कोडित है एन")

नील के विचार ने 2n XOR nमुझे सभी तरह से छांटने की कोशिश की, इसलिए मैंने इस प्रकार के पीछे के सूचक खोजने की कोशिश की। मैंने यह कोड लिखा है , और यह बताता है कि हम कुछ इस तरह लिख सकते हैं:

for n in range(400):x=a(n);print 2*x^x

जहाँ a(n)A006068 (n) है। इसे ऑनलाइन आज़माएं!

हालाँकि, यह मानता है कि हमारे पास A006068 की गणना करने का कुछ छोटा तरीका है। यह पहले से ही 38 बाइट्स है, यह मानते हुए कि हम इसकी गणना 4 बाइट्स ( a(n)भाग) में कर सकते हैं। वास्तविक कार्यान्वयन (TIO हेडर में) इससे कहीं अधिक लंबा है। मुझे नहीं लगता कि इसके लिए बहुत उम्मीद है।

Answer 10

विचार: XOR पर कम करें

यदि आप nएक साथ सभी बिट्स XOR करते हैं, तो यह 0बुराई के लिए और 1गैर-बुराई के लिए होगा। आप इसे एक पुनरावर्ती कार्य के साथ कर सकते हैं (जो इस प्रकार अधिक समय ले सकता है?), जैसे:

f=lambda n:f(n/2^n&1)if n>1else-~-n

यह बुराई के लिए 1 देता है।

यह 35 बाइट्स है, और यह जांचता है कि कोई संख्या बुराई है या नहीं। दुर्भाग्य से, filterपहले से ही 6 बाइट्स हैं, इसलिए यह इष्टतम समाधान शब्दशः नहीं था, लेकिन यह विचार शायद गोल्फ हो सकता है।

Comments

मुझे लगता है कि आप f=lambda n:n>1and f(n/2^n&1)or-~-n-1 बाइट के लिए कर सकते हैं ।

— आउटगॉल्फ

@EriktheOutgolfer मैंने कोशिश की, लेकिन त्रुटि का कारण बनता है जब f(n/2^n&1)रिटर्न 0 ...

— HyperNeutrino

Answer 11

प्रतिस्थापन विधि: {1 -> {1, -1}, -1 -> {-1, 1}}

आप इस प्रतिस्थापन को 10 बार {1 -> {1, -1}, -1 -> {-1, 1}} भी कर सकते हैं, फिर 1 के पदों को समतल और जांचें।

यहाँ गणित कोड है

(F = Flatten)@
Position[F@Nest[#/.{1->{1,-1},-1->{-1,1}}&,1,10],1][[;; 400]] - 1

Comments

आप अजगर में यह कैसे करेंगे?

— अनीश दुर्ग

@AneeshDurg क्या आपको इस समाधान में कुछ भी दिलचस्प लगता है? बॉक्स से बाहर सोचें और आपको जीवन का अर्थ AKA 42

— J42161217