आधा, आधा आधा, और, आधा

Question

निम्नलिखित संख्या अनुक्रम पर विचार करें:

$0, \frac{1}{2}, \frac{1}{4}, \frac{3}{4}, \frac{1}{8}, \frac{3}{8}, \frac{5}{8}, \frac{7}{8}, \frac{1}{16}, \frac{3}{16}, \frac{5}{16}, \frac{7}{16}, \frac{9}{16}, \frac{11}{16}, \frac{13}{16}, \frac{15}{16}, \frac{1}{32}, \frac{3}{32}, \frac{5}{32}, \dots$

यह इकाई अंतराल में सभी द्विआधारी अंशों की गणना करता है ।$[0, 1)$

(इस चुनौती को आसान बनाने के लिए, पहला तत्व वैकल्पिक है: आप इसे छोड़ सकते हैं और विचार कर सकते हैं कि अनुक्रम 1/2 से शुरू होता है।)

कार्य

एक कार्यक्रम (पूरा कार्यक्रम या एक समारोह) लिखें जो ...

इनमें से एक व्यवहार चुनें:

• इनपुट n, अनुक्रम का आउटपुट nth तत्व (0-अनुक्रमित या 1-अनुक्रमित);
• इनपुट एन, अनुक्रम के पहले एन तत्वों का उत्पादन;
• इनपुट कुछ भी नहीं, अनंत संख्या अनुक्रम को आउटपुट करें जिसे आप एक-एक करके ले सकते हैं;

नियम

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

परीक्षण के मामलों

input output
1     1/2     0.5
2     1/4     0.25
3     3/4     0.75
4     1/8     0.125
10    5/16    0.3125
100   73/128  0.5703125
511   511/512 0.998046875
512   1/1024  0.0009765625

ये उदाहरण 0-अनुक्रमित अनुक्रम पर आधारित हैं जिनमें प्रमुख 0 शामिल हैं। आपको अपने समाधान की फिटिंग के लिए इनपुट को समायोजित करने की आवश्यकता होगी।

और पढो

• OEIS A006257
  • जोसेफस समस्या: । (पूर्व में एम 2216)$a_{2n} = 2a_n-1, a_{2n+1} = 2a_n+1$
  • 0, 1, 1, 3, 1, 3, 5, 7, 1, 3, 5, 7, 9, 11, 13, 15, 1, 3, 5, ...
• OEIS A062383
  • :,या।$a_0 = 1$$n>0$$a_n = 2^{\lfloor log_2n+1 \rfloor}$$a_n = 2a_{\lfloor \frac{n}{2} \rfloor}$
  • 1, 2, 4, 4, 8, 8, 8, 8, 16, 16, 16, 16, 16, 16, 16, 16, 32, 32, 32 ...

• A006257 (n) / A062383 (n) = (0, 0.1, 0.01, 0.11, 0.001, ...) इकाई अंतराल [0, 1) में सभी बाइनरी अंशों की गणना करता है। - फ्रेड्रिक जोहानसन, 14 अगस्त 2006

Comments

" इनपुट कुछ भी नहीं, अनंत संख्या अनुक्रम को एक-एक करके आउटपुट करें " क्या यह एक-एक करके होना है, या क्या हमें एक अनंत सूची (संभव हैस्केल, एलिक्सिर, 05AB1E, आदि) में आउटपुट करने की अनुमति है?

— बजे केविन क्रूज़सेन

क्या मैं स्ट्रिंग्स की सूची का उत्पादन कर सकता हूं? जैसे"1/2" "1/4" "1/8"...

— बरनका

@ केविनक्रूजसेन अनंत सूची तब तक ठीक है जब तक आप takeबाद में उससे तत्वों को ले सकते हैं ।

— tsh

@Barranka मुझे लगता है कि यह स्वीकार्य है। कि भिन्न करने के लिए अंशों को प्रिंट करना अलग नहीं है।

— tsh

जब आप कहते हैं कि इनपुट / आउटपुट बाइनरी नंबरों की अनुमति नहीं है , तो इसका मतलब है कि हम एक फ़ंक्शन नहीं लिख सकते हैं जो एक जोड़ी देता है यदि intएस, या doubleएक भाषा / कार्यान्वयन में जहां doubleIEEE बाइनरी 64 प्रारूप का उपयोग करता है ? मुझे आशा है कि अगर आप पूर्णांक इनपुट लेना चाहते हैं तो आपके पास ASCII स्ट्रिंग को पार्स करने का कोई मतलब नहीं है? सामान्य पूर्णांक प्रकार सी जैसी भाषाओं में द्विआधारी होते हैं या क्या आपका मतलब है कि इनपुट / आउटपुट पूर्णांक या ASCII शून्य / वाले का एक सरणी या स्ट्रिंग नहीं हो सकता है?

— पीटर कॉर्ड्स

Answer 1

हास्केल , 25 बाइट्स

pred.until(<2)(/2).(+0.5)

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

आउटपुट दशमलव, प्रारंभिक शून्य अवधि के बिना एक-अनुक्रमित।

इनपुट में 0.5 जोड़ता है, फिर तब तक रुका रहता है जब तक परिणाम 2 से कम नहीं हो जाता, तब घटाता है। 1. पॉइंटफ्री एक्सप्रेशन का उपयोग करने से बाय बाय ओवर बच जाता है

f n=until(<2)(/2)(n+0.5)-1

Answer 2

जावा 10, 68 64 बाइट्स

पहले कोड गोल्फ में प्रयास करें!

विकल्प 1: n -th तत्व खोजें (1-अनुक्रमित)

-4 बाइट्स @ केविन क्रूज़सेन को धन्यवाद

n->{int x=0;for(;n>>++x!=1;);return((~(1<<x)&n)*2.+1)/(1<<x+1);}

यह एक अज्ञात विधि है कि पाता है n से सबसे महत्वपूर्ण बिट को हटाने के द्वारा मई के कार्यकाल में एन , यह दोहरीकरण और एक जोड़ने, तो 2 की अगली सर्वोच्च शक्ति से विभाजित।

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

कोड वॉकथ्रू:

n->{                      // builds anonymous function with input n
int x=0;                  // stores floor of log(n) (base 2) for most significant digit
for(;n>>++x!=1;);         // calculates floor of log(n) by counting right shifts until 1
return((~(1<<x)&n)        // removes most significant digit of n
*2.+1)                     // multiplies 2 and adds 1 to get the odd numerator
/(1<<x+1);}               // divides by the next highest power of 2 and returns`

यदि इसे वापस करने के बजाय अंतिम मूल्य प्रिंट करना आवश्यक है तो संपादित करेंगे।

Comments

पीपीसीजी में आपका स्वागत है, हमारे साथ आपके साथ अच्छा है :)

— झबरा

नमस्ते, PPCG में आपका स्वागत है! महान पहला जवाब, +1 मुझसे। वर्तमान में यह मेरे जावा उत्तर के समान ही बाइट-काउंट है, लेकिन आप इसे अभी भी अपने हिस्से के कुछ हिस्से को गोल्फ से मेरा छोटा बना सकते हैं: {}लूप के ;बजाय एक हो सकता है ; आप के बाद अंतरिक्ष को हटा सकते हैं return; 2.0हो सकता है 2.; और बदलते n>>x!=1;x++, 1<<xऔर 1<<x+1करने के लिए n>>x++!=1;, 1<<x-1, 1<<xक्रमशः भी एक बाइट बचाता है। इसे ऑनलाइन आज़माएँ: 64 बाइट्स । यहां रहने का आनंद!

— केविन क्रूज़सेन

ओह, और अगर आपने इसे अभी तक नहीं देखा है: जावा में गोल्फिंग के लिए टिप्स और <सभी भाषाओं में गोल्फिंग के लिए टिप्स>> दोनों के माध्यम से पढ़ने के लिए बहुत दिलचस्प हैं। :)

— केविन क्रूज़सेन

मूल रूप से आपके और गोल्फ वाले और गोल्फ वाले के आधार पर, मेरे 30 बाइट्स जवाब देखें ।

— ओलिवियर ग्रेजायर

Answer 3

मैथॉल्फ , 5 4 बाइट्स

╫\╨]

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

यह ठीक से काम करने वाले ऑपरेटर के साथ कैसा लगेगा

╫\)╨]   (")" adds 1 to TOS, making rounding behave as expected)

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

व्याख्या

╫     Left-rotate all bits in input
 \    Swap top two elements on stack, pushing the input to the top
  ╨   Round up to nearest power of 2
   ]  Wrap in array (just for pretty printing)

मैंने इस सवाल से अपनी प्रेरणा ली , समस्या को हल करने के लिए, मेरा "स्वयं" समाधान लगभग 10-12 बाइट्स था जो मुझे लगता है।

मैंने 2 को निकटतम संख्या में राउंड अप करने का इरादा किया था, यदि वह दो की संख्या थी, तो संख्या को स्वयं ही वापस करने के लिए, लेकिन एक गलती के कारण यह दो की अगली शक्ति के लिए गोल होता है (जैसे 4 -> 8 के बजाय 4 -> 4 )। इसे बाद में ठीक करना होगा, लेकिन अब यह मुझे एक बाइट बचाता है।

Comments

मुझे MathGolf का पता नहीं है, लेकिन अगर ]आउटपुट स्वरूपण के अलावा कोई अन्य उद्देश्य नहीं है, तो मैं कहूंगा कि आपको इसे अपनी बाइट में शामिल करने की आवश्यकता नहीं है।

— झबरा

मैं इसके बारे में अनिश्चित था। चूंकि स्टैक आउटपुट में एक सम्मिलित स्ट्रिंग के रूप में मुद्रित होता है, यह संख्या 1 और 2 के साथ एक स्टैक को 12 के रूप में आउटपुट करता है। अगर अभी भी मायने रखता है कि मैं एक बाइट हटा

— दूंगा

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

— H.PWiz

@ H.PWiz जो मेरी मूल सोच थी, क्योंकि आपकी भाषा की ताकत का उपयोग करना उचित लगता है। कुछ भाषाएं समाप्त होने पर केवल स्टैक के शीर्ष को प्रिंट करती हैं, कुछ इसे सूची के रूप में प्रिंट करती हैं। आमतौर पर यह 1 बाइट अंतर होता है, लेकिन यह चुनौती का हिस्सा है।

— अधिकतम

Answer 4

जावा 10, 89 85 70 69 68 बाइट्स

v->{for(float j,t=2;;t*=2)for(j=1;j<t;j+=2)System.out.println(j/t);}

पोर्ट @Emigma का 05AB1E उत्तर है , इसलिए आउटपुट को अनिश्चित काल के लिए भी निर्धारित करता है।
-15 बाइट्स @Arnauld को धन्यवाद ।

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

स्पष्टीकरण:

v->{                      // Method with empty unused parameter and no return-type
  for(float j,t=2;;       //  Loop `t` from 2 upwards indefinitely,
                   t*=2)  //  doubling `t` after every iteration
    for(j=1;j<t;          //   Inner loop `j` in the range [1, `t`),
                j+=2)     //   in steps of 2 (so only the odd numbers)
      System.out.println( //    Print with trailing new-line:
        j/t);}            //     `j` divided by `t`

Comments

मैं कितनी बार कह सकता हूं कि मैं आपकी आधी बाइट गिनता हूं? खैर, मुझे लगता है कि यह पहली बार है ;-)

— ओलिवियर ग्रेजायर

@ OlivierGrégoire डांग, अब यह एक प्रभावशाली जावा उत्तर है। :) मैंने आपके 37-बाइट संस्करण को TCFP के उत्तर पर टिप्पणी के रूप में देखा, लेकिन आपने और भी बाइट्स छीन लिए। यह आपके 30-बाइट संस्करण में अब बहुत सरल लग रहा है, लेकिन यह अभी भी सरल है कि आपने इसे प्रारंभिक संस्करण से कैसे तैयार किया है। बहुत बढ़िया!

— केविन क्रूज़सेन

Answer 5

पर्ल 6 , 19 बाइट्स

{($_+.5)/2**.msb-1}

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

Answer 6

पायथन 3 , 33 बाइट्स

lambda n:(8*n+4)/2**len(bin(n))-1

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

आउटपुट दशमलव, प्रारंभिक शून्य अवधि के बिना एक-अनुक्रमित।

Answer 7

जावा (JDK 10) , 30 बाइट्स

n->(n+.5)/n.highestOneBit(n)-1

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

अनुक्रम में n ^वें आइटम को लौटाता है ।

यह उत्तर मूल रूप से टीसीएफपी के जावा उत्तर के गोल्फरों का उत्तराधिकार है । अंत में, गोल्फ अब मूल उत्तर की तरह नहीं दिखते थे (हालांकि गणित का उपयोग समान है) इसलिए मैंने टीसीपीएफ के उत्तर पर केवल टिप्पणी करने के बजाय एक अलग उत्तर के रूप में गोल्फ पोस्ट करने का फैसला किया। तो अगर आपको यह उत्तर पसंद है, तो टीसीपीएफ के उत्तर को भी बढ़ाएँ ! ;-)

इंटरमीडिएट गोल्फ थे:

n->{int x=0;for(;n>>++x!=1;);return((~(1<<x)&n)*2.+1)/(1<<x+1);} // 64 bytes (TCFP's answer when I started golfing)
n->{int x=0;for(;n>>++x!=1;);x=1<<x;return((~x&n)*2.+1)/x/2;}    // 61 bytes
n->{int x=n.highestOneBit(n);return((~x&n)*2.+1)/x/2;}           // 54 bytes
n->{int x=n.highestOneBit(n);return((~x&n)+.5)/x;}               // 50 bytes
n->((n&~(n=n.highestOneBit(n)))+.5)/n                            // 37 bytes
n->(n-(n=n.highestOneBit(n))+.5)/n                               // 34 bytes
n->(n+.5)/n.highestOneBit(n)-1                                   // 30 bytes, current score

Comments

और मैं यहाँ बैठ कर सोच रहा था कि मेरा उत्तर उतना ही छोटा है जितना कि मैं इसे बना सकता हूँ, तुम साथ आओ और इसे आधे से अधिक काट दो! अद्भुत सामान, निश्चित रूप से मेरे से एक +1 का हकदार है।

— टीसीएफपी

@TCFP यह कई घंटों के अंतराल पर एक पुनरावृत्त प्रक्रिया थी। मैंने वास्तव में प्रत्येक मध्यवर्ती गोल्फिंग को आपके उत्तर के लिए एक टिप्पणी के रूप में पोस्ट किया था, लेकिन मैंने उन्हें बेहतर गोल्फ के रूप में हटा दिया। प्रशंसा के लिए धन्यवाद ;-)

— ओलिवियर ग्रेजायर

Answer 8

05AB1E , 11 8 बाइट्स

केविन क्रूज़सेन के लिए धन्यवाद 3 बाइट्स बचाए ।

∞oDÅÉs/˜

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

व्याख्या

∞         # start an infinite list [1...
 o        # calculate 2**N
  D       # duplicate
   ÅÉ     # get a list of odd numbers up to 2**N
     s/   # divide each by 2**N
       ˜  # flatten

Comments

-1 बाइट का उपयोग करके ∞(1 पर शुरू होने वाली अनंत सूची):∞oεDÅÉs/}˜

— केविन क्रूज़सेन

@ केविनक्रूजसेन: कूल! यह एक ऐसी आज्ञा है जिसे मैंने पहले नहीं देखा था। धन्यवाद :)

— Emigna

आह, और अंतर्निहित मानचित्रण के कारण दो और बाइट्स को बचाने का अच्छा तरीका .. इस बारे में सोचा भी नहीं था, योग्य ..

— केविन क्रूज़सेन

: ओ ये कैसे संभव है। आपने ~ 2 पेज के प्रश्न को 8 बाइट्स में संघनित किया।

— कुल्लू

मैं सोच रहा था कि प्राइम नंबरों और लिस्ट का इस्तेमाल करके [1,2,4,4,8,8,8,8,16,16,...,2**n]सही इंडेक्स किए गए प्राइम को प्रीपेड किया जाए /... लेकिन वह इतना अच्छा काम नहीं कर रहा था। ठीक है, लेकिन 8-bytesअच्छी तरह से नहीं । कुछ इस तरह 9LoDÅP)ζ।

— मैजिक ऑक्टोपस Urn

Answer 9

जेली , 9 बाइट्स

Bṙ1Ḅ,æċ2$

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

Answer 10

पॉवरशेल , 40 बाइट्स

for($i=2;;$i*=2){1..$i|?{$_%2}|%{$_/$i}}

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

दशमलव मान के रूप में अनंत अनुक्रम को आउटपुट करता है। भाषा की सीमाओं को देखते हुए, अंततः सटीक समस्याओं में चलेगा, लेकिन आसानी से पहली 1000 प्रविष्टियों को संभालता है।

सेटिंग से शुरू होता है $i=2, फिर एक forलूप में प्रवेश करता है । प्रत्येक पुनरावृत्ति, हम से एक सीमा का निर्माण 1..$iकरते हैं और विषम मानों को बाहर निकालते हैं |?{$_%2}। उन्हें अपने स्वयं के आंतरिक लूप में खिलाया जाता है, जहां हम प्रत्येक को दशमलव प्राप्त करने के लिए विभाजित करते हैं |%{$_/$i}। उन पाइप लाइन और आउटपुट पर छोड़ दिया जाता है जब पाइपलाइन हर forपुनरावृत्ति के बाद बह जाती है। प्रत्येक यात्रा हम बस incrementing रहे $iद्वारा $i*=2अगले जाने के दौर पाने के लिए।

Answer 11

हास्केल, 35 32 बाइट्स

संपादित करें: -3 बाइट्स @ Delfad0r के लिए धन्यवाद।

[(y,2^x)|x<-[1..],y<-[1,3..2^x]]

यह पूर्णांक जोड़े की एक अनंत सूची है।

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

Answer 12

हास्केल , 40 बाइट्स

s=(1,2):[(i*2+u,j*2)|(i,j)<-s,u<-[-1,1]]

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

पूर्णांक के जोड़े के रूप में अनंत अनुक्रम (से शुरू (1,2))।

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

यह समाधान निम्नलिखित अवलोकन पर आधारित है।

$$\left\{\frac{1}{2},\frac{1}{4},\frac{3}{4},\frac{1}{8},\frac{3}{8},\frac{5}{8},\frac{7}{8},\frac{1}{16},\frac{3}{16},\ldots\right\}$$

• हर नंबर बदलें$\frac{i}{j}$$\left\{\frac{2i-1}{2j},\frac{2i+1}{2j}\right\}$ $$\left\{\left\{\frac{1}{4},\frac{3}{4}\right\},\left\{\frac{1}{8},\frac{3}{8}\right\},\left\{\frac{5}{8},\frac{7}{8}\right\},\left\{\frac{1}{16},\frac{3}{16}\right\},\ldots\right\}$$
• $$\left\{\frac{1}{4},\frac{3}{4},\frac{1}{8},\frac{3}{8},\frac{5}{8},\frac{7}{8},\frac{1}{16},\frac{3}{16},\ldots\right\}$$
• जोड़ना $\frac{1}{2}$ अनुक्रम की शुरुआत में: $$\left\{\frac{1}{2},\frac{1}{4},\frac{3}{4},\frac{1}{8},\frac{3}{8},\frac{5}{8},\frac{7}{8},\frac{1}{16},\frac{3}{16},\ldots\right\}$$

ध्यान दें कि आपके द्वारा शुरू किए गए अनुक्रम में आप कैसे वापस आते हैं!

यह अनुक्रम अनुक्रम की गणना करने के लिए इस तथ्य (हास्केल के आलस्य के साथ) का फायदा उठाता है s।

Answer 13

पायथन 2 - 68 66 बाइट्स

-2 बाइट्स केविन की बदौलत

from math import*
def g(n):a=2**floor(log(n,2));print(n-a)*2+1,2*a

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

Comments

आप को बदलने के द्वारा गोल्फ 1 बाइट कर सकते हैं return 2*(n-a)करने के लिए return(n-a)*2। और आप 3 के बजाय पायथन 2 का उपयोग करके एक अतिरिक्त बाइट बचा returnसकते हैं , इसलिए print(कोष्ठक के साथ) हो सकता है ।

— केविन क्रूज़सेन

@ केविनक्रूजसेन किसी के लिए जो पायथन का उपयोग नहीं करता है, आप निश्चित रूप से मुझसे बेहतर पायथन प्रोग्रामर हैं।

— डॉन थाउजेंड

हेहे। : डी सिंपल चीजें इस तरह अनुभव के साथ आती हैं जो मुझे लगता है। मैं इस साइट पर लगभग दो साल से हूं। मुझे लगता है कि (EDIT: अप्रैल 2016 से)। मैं कभी-कभी उन बातों के लिए भी गोल्फ को सुझाव देता हूं जो उन भाषाओं में लिखी जाती हैं, जिन्हें मैंने पहले कभी नहीं देखा था। कुछ बुनियादी चीजें ज्यादातर भाषाओं में काम करती हैं। उदाहरण के लिए, पिछले हफ्ते मैंने टी-एसक्यूएल जवाब के लिए एक गोल्फ का सुझाव दिया था , और मैंने एक बार एक रेड सुझाव में गोल्फ का सुझाव दिया था । xD

— केविन क्रूजेसेन

के बजाय 44 बाइट्स का उपयोग करना lenऔर । binlog

— ovs

@ovs 42 बाइट्स ।

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

Answer 14

पायथन 3 , 53 51 बाइट्स

• सहेजे गए दो बाइट्स के लिए धन्यवाद Mypetlion सहेजे गए ; रीसेट करने के लिए डिफ़ॉल्ट मापदंडों का पुन: उपयोग n।

def f(m=2,n=1):n<m and print(n/m)&f(m,2+n)or f(m+m)

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

Comments

2 बाइट बचाने के लिए मापदंडों को स्वैप करें:def f(m=2,n=1):n<m and print(n/m)&f(m,n+2)or f(m+m)

— mypetlion

@Mypetlion कूल, धन्यवाद!

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

Answer 15

आर , 42 बाइट्स

function(n)c(y<-2^(log2(n)%/%1)*2,2*n-y+1)

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

एक जोड़ी लौटाता है Denominator,Numerator। सूत्र का उपयोग करता है $\begin{equation}N = 2*\left(n-2^{\lfloor \log_2(n)\rfloor}\right)+1\end{equation}$ जोसेफस अनुक्रम से और $\begin{equation}D = 2^{\lfloor \log_2(n)\rfloor+1}\end{equation}$दूसरे क्रम से। खुशी से हम हर को फिर से उपयोग करने में सक्षम हैं क्योंकि दो सूत्र आम में बहुत अधिक हैं!

Answer 16

रैकेट , 92 91 बाइट्स

(define(f k(m 2)(n 1))(if(> k 0)(if(=(+ n 1)m)(f(- k 1)(+ m m))(f(- k 1)m(+ n 2)))(/ n m)))

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

• Giuseppe के लिए एक बाइट धन्यवाद सहेजा गया - शानदार व्हाट्सएप को हटाने।

Answer 17

MATL , 8 बाइट्स

BnWGEy-Q

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

न्यूमेटर लौटाता है, फिर डेनोमिनेटर। मेरे R उत्तर के समान विधि का उपयोग करता है , हालाँकि यह थोड़ा अधिक कुशल है।

इनपुट के साथ स्पष्टीकरण 5:

           # implicit input 5
B          # convert to array of bits
           # STACK: [[1 0 1]]
n          # length (place of Most Significant Bit)
           # STACK: [3]
W          # elementwise raise 2^x
           # STACK: [8]
G          # paste input
           # STACK: [8, 5]
E          # double
           # STACK: [8, 10]
y          # copy from below
           # STACK: [8, 10, 8]
-          # subtract
           # STACK: [8, 2]
Q          # increment
           # STACK: [8, 3]
           # implicit end of program, display stack contents

Answer 18

शेक्सपियर प्रोग्रामिंग लैंग्वेज , 426 बाइट्स

,.Ajax,.Ford,.Act I:.Scene I:.[Exeunt][Enter Ajax and Ford]Ajax:You be the sum ofyou a cat.Ford:You cat.Scene V:.Ford:Is twice you nicer I?If solet usScene X.You be twice you.Let usScene V.Scene X:.Ford:Remember twice you.You be the sum oftwice the remainder of the quotient betweenI you a cat.Open heart.You big big big big big cat.Speak thy.Recall.Open heart.You be twice the sum ofa cat a big big cat.Speak thy.Let usAct I.

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

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

Comments

इसे प्यार करना। लोलYou be twice the sum of a cat

— कुल्लूब

दरअसल, यह "दो बार सुरा बिल्ली का एक बड़ा बिल्ली" (किसी कारण से 10) है।

— जोशियाहैन

Answer 19

पायथन 2 , 44 बाइट्स

def f(n):m=2**len(bin(n))/4;return 2*n-m+1,m

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

फ़ंक्शन (अंश, हर) का एक टपल देता है। 0 का इनपुट संभाला नहीं गया है (यह वैकल्पिक था)।

Comments

return 2*n-m+1,mprint-~n+n-m,m2 बाइट बचाने के लिए किया जा सकता है।

— केविन क्रूज़सेन

Answer 20

एक्सेल 48 28 बाइट्स

टीशर्ट के लिए धन्यवाद 20 बाइट्स (!) को बचाया

=(A1+0.5)/2^INT(LOG(A1,2))-1

= एमओडी (A1 + 0.5,2 ^ (INT (लॉग (A1,2)))) / 2 ^ INT (लॉग (A1,2))

A1 में मान लेता है, आउटपुट दशमलव में है। यदि आप चाहते हैं कि आउटपुट अंश में हो, तो आप आउटपुट सेल के लिए एक कस्टम प्रारूप "0 / ### 0" के रूप में बना सकते हैं और यह इसे अंश के रूप में दिखाएगा।

स्पष्टीकरण: इस सूत्र को प्राप्त करने के लिए लिया गया एक शॉर्टकट है, क्योंकि व्याख्या करना मुश्किल है। मूल रूप से अंश इनपुट की थोड़ी शिफ्ट है, और भाजक संख्या इनपुट की तुलना में 2 अधिक की अगली शक्ति है।

मैंने मूल रूप से BITLSHIFT और BITRSHIFT के कार्यों में निर्मित एक्सेल के साथ शुरुआत की, लेकिन वे पूरे 48 बिट्स को स्थानांतरित कर देंगे जो कि आप नहीं चाहते हैं। DEC2BIN (और BIN2DEC) के फंक्शन में -512 से 511 (10 बिट्स) की सीमा होती है, इसलिए यह काम नहीं करेगा। इसके बजाय मुझे मूल संख्या के मापांक के साथ संख्या का पुनर्निर्माण करना था, फिर दो बार, फिर 1 जोड़ें (चूंकि बाएं अंक हमेशा एक पारी से पहले 1 होगा)।

=MOD(A1                        Use MOD for finding what the right digits are
       +0.5                    this will later add the left "1" to the right digits
           ,2^INT(LOG(A1,2)))) Take Log base 2 number of digits on the right
                               this creates the numerator divided by 2 (explained later)
/ 2^INT(LOG(A1,2))             The denominator should be 2^ (Log2 + 1) but instead of 
                               adding a 1 here, we cause the numerator to be divided by 2 instead
                               This gives us a fraction.  In the numerator, we also added .5
                               instead of 1 so that we wouldn't need to divide it in both the
                               numerator and denominator
Then tsh showed how I could take the int/log out of the mod and remove it from numerator/denominator. 

उदाहरण:

Comments

किस बारे में =(A1+0.5)/2^INT(LOG(A1,2))-1?

— tsh

Answer 21

सी ++, 97 75 71 बाइट्स

-26 बाइट्स टीश, सीलिंगकैट, ज़ाचरी के लिए धन्यवाद

float f(int i){float d=2,n=1;while(--i)n=d-n==1?d*=2,1:n+2;return n/d;}

परीक्षण कोड:

std::cout << "1\t:\t" << f(1) << '\n';
std::cout << "2\t:\t" << f(2) << '\n';
std::cout << "3\t:\t" << f(3) << '\n';
std::cout << "4\t:\t" << f(4) << '\n';
std::cout << "10\t:\t" << f(10) << '\n';
std::cout << "100\t:\t" << f(100) << '\n';
std::cout << "511\t:\t" << f(511) << '\n';
std::cout << "512\t:\t" << f(512) << '\n';

Comments

if(!i)return 0;चुनौती में 0 की आवश्यकता नहीं है, क्योंकि आप बस छोड़ सकते हैं ।

— tsh

जब सी-लाइक भाषा को गोल्फ करने की कोशिश की जा रही है। आपको प्रयोग whileकरने से बचना चाहिए लेकिन प्रयास करना चाहिए for। for(;exp;)के रूप में ही है, while(exp)लेकिन आप इसे में दो और बयान लिख सकते हैं ?:इसके बजाय प्राथमिकता दें if else, जो ज्यादातर मामलों में कम होगा।

— tsh

मुझे नहीं लगता कि आपको (...)आसपास की जरूरत है d-n-1।

— ज़ाचारि

Answer 22

सी (जीसीसी) , 63 बाइट्स

कोई इनपुट नहीं, अनंत अनुक्रम प्रिंट करता है:

f(i,j){for(i=1,j=2;;i+=2,i>j&&(j*=2,i=1))printf("%d/%d ",i,j);}

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

Comments

60 बाइट्स ।

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

@

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

Answer 23

जावास्क्रिप्ट (ईएस 6), 44 बाइट्स

लौटता है $n$-तब्द, 1-अनुक्रमित।

f=(n,p=q=1)=>n?f(n-1,p<q-2?p+2:!!(q*=2)):p/q

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

Answer 24

रूबी , 42 बाइट्स

1.step{|i|(1..x=2**i).step(2){|j|p [j,x]}}

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

प्रिंटों के पूर्णांक जोड़े अनंत रूप से, 1/2 से शुरू होते हैं।

Answer 25

जावास्क्रिप्ट (Node.js) , 30 बाइट्स

f=(n,d=.5)=>d>n?n/d:f(n-d,d*2)

इसे ऑनलाइन आज़माएं! 0 अनुक्रमित। मेरे बैच उत्तर के एक बंदरगाह के रूप में शुरू किया गया था, लेकिन मैं के गुणकों में गणना करने में सक्षम था$\frac{1}{2}$ जिसने कई बाइट्स बचाए।

Answer 26

रूबी , 31 बाइट्स

->x{(2r*x+1)/2**x.bit_length-1}

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

Answer 27

> <> , 19 18 बाइट्स

जो किंग द्वारा निर्धारित xnor के विचार का उपयोग करना , -1 बाइट दर्पण का बेहतर उपयोग करके और दूसरा -2 बाइट जो किंग द्वारा किया !गया था क्योंकि वह बहुत अधिक नहीं था और ;इसकी आवश्यकता नहीं थी।

2*1+\1-n
2:,2/?(

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

Comments

You should be checking if it is smaller than 2 first, otherwise the first element is -0.25. Fix for the same amount of bytes

— Jo King

Thanks! I also managed to remove another byte by reusing the mirrors.

— PidgeyUsedGust

Why did you invert the condition? 16 bytes

— Jo King

Didn't notice that it would continue the loop. Are we allowed to not properly finish?

— PidgeyUsedGust

हाँ, एक त्रुटि के साथ समाप्त करना ठीक है जब तक कि ओपी अन्यथा निर्दिष्ट नहीं करता है

— जो किंग

Answer 28

वोल्फ्राम भाषा (गणितज्ञ) , 22 बाइट्स

2^Mod[Log2[2#+1],1]-1&

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

Answer 29

एपीएल (डायलॉग यूनिकोड) , 15 बाइट्स

1-⍨.5∘+÷2*∘⌊2⍟⊢

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

अनाम उपसर्ग लंबोदर।

4 बाइट्स के लिए Adám और 2 बाइट्स के लिए गायों को धन्यवाद।

किस तरह:

1-⍨.5∘+÷2*∘⌊2⍟⊢ ⍝ Anonymous lambda, argument ⍵ → 10
            2⍟⊢ ⍝ Log (⍟) of ⍵ in base 2. 2⍟10 → 3.32192809489...
           ⌊     ⍝ Floor. ⌊3.32192809489... → 3
        2*∘      ⍝ Take that power of 2. 2³ → 8
       ÷         ⍝ Use that as denominator
   .5∘+          ⍝ ⍵ + 0.5 → 10.5. Using that as numerator: 10.5÷8 → 1.3125
1-⍨              ⍝ Swap the arguments (⍨), then subtract. 1-⍨1.3125 → 1.3125-1 → 0.3125

Answer 30

सी # (.NET कोर) , 69 बाइट्स

a=>{int b=1,c=2;while(a-->1){b+=2;if(b>c){b=1;c*=2;}}return b+"/"+c;}

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

Ungolfed:

a=> {
    int b = 1, c = 2;   // initialize numerator (b) and denominator (c)
    while (a-- > 1)     // while a decrements to 1
    {
        b += 2;         // add 2 to b
        if (b > c)      // if b is greater than c:
        {
            b = 1;      // reset numerator to 1
            c *= 2;     // double denominator
        }
    }
    return b + "/" + c; // return fraction as string
}