बाइनरी विस्तार के विशिष्ट गैर-खाली बाद की संख्या

19

एक क्रम कोई भी अनुक्रम है जिसे आप किसी भी वर्ण को हटाकर दूसरे से प्राप्त कर सकते हैं। के विशिष्ट गैर खाली subsequences 100हैं 0, 1, 00, 10, 100। के विशिष्ट गैर खाली subsequences 1010हैं 0, 1, 00, 01, 10, 11, 010, 100, 101, 110, 1010।

एक प्रोग्राम या समारोह है कि एक सकारात्मक पूर्णांक दी लिखें एन की बाइनरी विस्तार के विशिष्ट गैर खाली subsequences की संख्या रिटर्न एन ।

उदाहरण: के बाद से 4है 100बाइनरी में, और हमने देखा कि यह ऊपर पांच अलग गैर खाली subsequences थी, इसलिए f(4) = 5। N = 1 से शुरू होकर क्रम शुरू होता है:

1, 3, 2, 5, 6, 5, 3, 7, 10, 11, 9, 8, 9, 7, 4, 9, 14, 17, 15, 16, 19, 17, 12

हालाँकि, आपके प्रोग्राम को किसी भी आधुनिक मशीन पर सेकंड के तहत किसी भी n <2 50 के लिए काम करना चाहिए । कुछ बड़े उदाहरण:

f(1099511627775) = 40
f(1099511627776) = 81
f(911188917558917) = 728765543
f(109260951837875) = 447464738
f(43765644099) = 5941674
code-golf  combinatorics  binary  subsequence  restricted-time 
— orlp
स्रोत
4
मैं समय की पाबंदी से असहमत हूं।
— अताको
1
यह वास्तव में परिचित लग रहा था, खासकर भूखंड को देखने के बाद। बारी-बारी से बाहर मैं एक बहुत ही बारीकी से जुड़े अनुक्रम में देखा इस साल के हैं, लेकिन मैं अलग द्विआधारी संख्या, द्विआधारी नहीं तार की संख्या की गणना, आप जब subsequences लेने (तो मैं अग्रणी शून्य रियायती) मिलता है। मैंने इसे सैंडबॉक्स भी कर दिया था, लेकिन Math.SE पोस्ट में समतुल्यता के कारण, यह कुछ स्टर्न-ब्रोच चुनौती का एक हिस्सा था। आपके अनुक्रम का कथानक थोड़ा अच्छा है (अर्थात अधिक अराजक) यद्यपि। :)
— मार्टिन एंडर
5
@ATaco समय प्रतिबंध का एक अच्छा कारण है। एक कुशल एल्गोरिदम है, और यह दिलचस्प है फिर भी अच्छी तरह से गोल्फ है। अगर मेरे पास समय की पाबंदी नहीं है, तो मुझे लगता है कि लगभग हर उत्तर में बस सभी संभावित बादशाहों को बल मिलेगा, जो बहुत जल्दी, बहुत जल्दी काम करेंगे। एक मायने में वे गैर-उत्तर हैं।
— orlp

जवाबों:

10

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

[-12 बाइट्स Mr.XCoder के लिए धन्यवाद :)]

def f(x):
 v=[2,1];c=1
 for i in bin(x)[3:]:k=int(i);c+=v[k];v[1-k]+=v[k]
 return c

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

एल्गोरिथ्म पर एक नोट। एल्गोरिथ्म एक निश्चित स्थिति टी पर बिट द्वारा दिए गए अद्वितीय अनुवर्ती में वृद्धि की गणना करता है। पहले बिट के लिए वृद्धि हमेशा होती है। 1. एल्गोरिथ्म तब बिट्स एस (टी) के अनुक्रम पर चलता है और वृद्धि वी [एस (टी)] को जोड़ता है। प्रत्येक चरण में, s (t), v [1 - s (t)] के पूरक के लिए वृद्धि को v [1] + v [0] में अपडेट किया जाता है। अंतिम संख्या सभी वेतन वृद्धि का योग है।

इसे O (log2 (n)) में चलना चाहिए, जहाँ n इनपुट संख्या है।

— NofP
स्रोत
1
— श्री एक्सकोडर
8

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

f=(n,r=~(a=[]))=>n<1?~r:f(n/2,r*2-~~a[n&=1],a[n]=r)

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

कोड स्निपेट दिखाएं

प्रारूपित और टिप्पणी की गई

f = (                      // f is a recursive function taking:
  n,                       //   n = integer
  r = ~(                   //   r = last result, initially set to -1
    a = []                 //   and using a[] = last results for 0 and 1,
  )                        //   implicitly initialized to [0, 0]
) =>                       //
  n < 1 ?                  // if n is less than 1:
    ~r                     //   we're done: return -(r + 1)
  :                        // else:
    f(                     //   do a recursive call with:
      n / 2,               //     n / 2
      r * 2 - ~~a[n &= 1], //     updated result = r * 2 - last result for this binary digit
      a[n] = r             //     update last result for this binary digit
    )                      //   end of recursive call

गैर-पुनरावर्ती संस्करण, 63 बाइट्स

सहेजे गए 3 बाइट्स @ThePirateBay के लिए धन्यवाद

s=>[...s.toString(2)].map(l=c=>l[p=r,r=r*2-~~l[c],c]=p,r=1)|r-1

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

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
मुझे लगता है कि आप खाली फ़ंक्शन के बजाय mapफ्लैग वेरिएबल को इनर फंक्शन (पहला तर्क ) बताकर 3 बाइट्स बचा सकते हैं l।
@PirateBay अच्छा लगा। धन्यवाद!
— अरनौलड
7

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

f=lambda x,a=1,b=1:x and f(x/2,a+~x%2*b,x%2*a+b)or a+b-2

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

ले रहा है NofP से विधि ।

59 बाइट्स iteratively:

x=input()
v=[1,1]
while x:v[x%2]=sum(v);x/=2
print sum(v)-2

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

— XNOR
स्रोत
अच्छा एल्गोरिथ्म। क्या आप इसके बारे में सिर्फ एक छोटी व्याख्या जोड़ना चाहेंगे कि यह क्यों काम करता है?
— जोनाह
6

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

B3;BSṛ¦/’S

यह उपयोग करता है @ XNOR के सुधार पर @ NofP एल्गोरिथ्म ।

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

पृष्ठभूमि

आज्ञा देना ( 1 , ..., n ) एक परिमित बाइनरी अनुक्रम हो। प्रत्येक गैर नकारात्मक पूर्णांक के लिए k ≤ n , परिभाषित ओ कश्मीर की अनूठी subsequences की संख्या के रूप में (एक 1 , ..., एक कश्मीर ) है कि या तो खाली करें या में अंत कर रहे हैं 1 , जेड कश्मीर अद्वितीय subsequences हैं कि की संख्या के रूप में या तो खाली या समाप्त ० ।

स्पष्ट रूप से, ओ 0 = जेड 0 = 1 , क्योंकि खाली अनुक्रम का एकमात्र परिणाम खाली अनुक्रम है।

प्रत्येक सूचकांक के लिए कश्मीर , के subsequences की कुल संख्या (एक 1 , ..., एक कश्मीर ) है ओ कश्मीर + z कश्मीर 1 - (घटाकर 1 तथ्य के लिए खातों है कि दोनों ओ कश्मीर और जेड कश्मीर गिनती खाली अनुक्रम)। इसलिए गैर-रिक्त अनुवर्ती की कुल संख्या इसलिए ओ के + z k - 2 है । चुनौती ओ n + z n - 2 की गणना करने के लिए कहती है ।

जब भी कश्मीर> 0 , हम गणना कर सकते हैं ओ कश्मीर और जेड कश्मीर रिकर्सिवली। दो मामले हैं:

  • a k = १

    z कश्मीर = z k-1 , के बाद से (एक 1 , ..., एक K-1 ) और (एक 1 , ..., एक K-1 , 1) एक ही subsequences है कि में अंत 0 ।

    से प्रत्येक के लिए ओ कश्मीर - 1 की गैर खाली subsequences (एक 1 , ..., एक कश्मीर ) में है कि अंत 1 , हम पीछे चल निकाल सकते हैं 1 में से एक प्राप्त करने के लिए ओ कश्मीर -1 + z k-1 - 1 अनुवर्ती ( 1 , ..., एक के -1 ) । इसके विपरीत, एक जोड़कर 1 बाद से प्रत्येक के लिए ओ कश्मीर -1 + z k-1 - 1 में से एक में दृश्यों परिणाम ओ कश्मीर 1 - पूर्व दृश्यों। इस प्रकार, ओ के - 1 = ओk-1 + zk-1 - 1 और o k = o k-1 + z k-1 ।

  • a k = ०

    पिछले मामले के समान, हम पुनरावर्ती सूत्र ओ के = ओ के -1 और जेड के = जेड के -1 + ओ के -1 प्राप्त करते हैं ।

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

B3;BSṛ¦/’S  Main link. Argument: n (positive integer)

B           Binary; convert n to base 2.
 3;         Prepend a 3.
   B        Binary; convert all integers in the resulting array to base 2, mapping
            0 to [0], 1 to [1], and the prepended 3 to [1, 1].
       /    Reduce the resulting array by the quicklink to the left, which will be 
            called with left argument [x, y] (integer pair) and right argument [j] 
            (either [0] or [1]).
      ¦     Sparse application.
    S           Compute the sum (x + y) and...
     ṛ          for each index in the right argument (i.e., for j)...
            replace the element of [x, y] at that index with (x + y).
       ’    Decrement both integers in the resulting pair.
        S   Take the sum.
— डेनिस
स्रोत
हे डेनिस, क्या आप एल्गोरिथ्म क्यों काम करता है के बारे में एक छोटी व्याख्या जोड़कर बुरा लगेगा?
— योना
मैंने एक स्पष्टीकरण जोड़ा है।
— डेनिस
4

05AB1E , 12 बाइट्स

0¸sbvDO>yǝ}O

इसे ऑनलाइन आज़माएं! स्पष्टीकरण: जैसा कि अन्य उत्तरों से पता चलता है, एक बाइनरी स्ट्रिंग के लिए अनुवर्ती संख्या a..y01 में समाप्त होती है, जो बाइनरी स्ट्रिंग के लिए संख्या के समान है a..y, जबकि एक में समाप्त होने वाली 0संख्या बाइनरी के लिए कुल संख्या है। स्ट्रिंग a..y(जो प्रत्येक एक 0प्रत्यय प्राप्त करता है) प्लस 0अपने लिए। अन्य उत्तरों के विपरीत, मैं खाली क्रम को शामिल नहीं करता हूं क्योंकि यह प्रारंभिक राज्य के निर्माण के लिए एक बाइट बचाता है।

0¸s             Push [0] under the input
   b            Convert the input to binary
    v     }     Loop over the digits
     D          Duplicate the array
      O         Take the sum
       >        Increment
        yǝ      Replace the index corresponding to the binary digit
           O    Take the sum of the final array
— नील
स्रोत
1

जावा 8, 97 बाइट्स

n->f(n,1,1)long f(long n,long a,long b){return n>0?f(n/2,a+Math.floorMod(~n,2)*b,n%2*a+b):a+b-2;}

पोर्ट ऑफ @ एक्सनोर पायथन 2 उत्तर , जो बदले में @ नोफप पायथन 3 उत्तर का सुधार है ।

इसे यहाँ आज़माएँ।

शायद यह एक अच्छी बात है कि प्रतिबंधित-समय- टैग मौजूद था, क्योंकि मेरे पास शुरू में सभी बाद में bruteforce करने के लिए था:

import java.util.*;n->p(n.toString(n,2)).size()-1;Set p(String s){Set r=new HashSet();r.add("");if(s.isEmpty())return r;Set q=p(s.substring(1));r.addAll(q);for(Object o:q)r.add(""+s.charAt(0)+o);return r;}

इसे यहाँ आज़माएँ।

जिसने काम भी किया, लेकिन पिछले तीन परीक्षण मामलों के लिए बहुत लंबा रास्ता तय किया। इसका उल्लेख नहीं है कि यह अधिक लंबा है ( 208 204 बाइट्स )।

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

6502 मशीन कोड (C64), 321 बाइट्स

00 C0 20 FD AE A2 00 9D 4F C1 E8 20 73 00 90 F7 9D 4F C1 A0 FF C8 B9 4F C1 D0
FA A2 15 CA 88 30 0A B9 4F C1 29 0F 9D 4F C1 10 F2 A9 00 9D 4F C1 CA 10 F8 A9
00 A0 07 99 64 C1 88 10 FA A0 40 A2 6C 18 BD E4 C0 90 02 09 10 4A 9D E4 C0 E8
10 F2 A2 07 7E 64 C1 CA 10 FA 88 F0 13 A2 13 BD 50 C1 C9 08 30 05 E9 03 9D 50
C1 CA 10 F1 30 D1 A2 0F A9 00 9D 3F C1 CA D0 FA A9 01 8D 3F C1 8D 47 C1 A2 08
CA BD 64 C1 F0 FA A0 09 1E 64 C1 88 90 FA B0 0A CA 30 28 A0 08 1E 64 C1 90 04
A9 47 B0 02 A9 4F 8D AF C0 86 FE A2 F8 18 BD 47 C0 7D 4F C0 9D 47 C0 E8 D0 F4
A6 FE 88 D0 DC F0 D5 A2 F8 BD 47 C0 7D 4F C0 9D 6C C0 E8 D0 F4 AD 64 C1 E9 01
8D 64 C1 A2 F9 BD 6C C0 E9 00 9D 6C C0 E8 D0 F5 A0 15 A9 00 99 4E C1 88 D0 FA
A0 40 A2 13 BD 50 C1 C9 05 30 05 69 02 9D 50 C1 CA 10 F1 0E 64 C1 A2 F9 3E 6C
C0 E8 D0 FA A2 13 BD 50 C1 2A C9 10 29 0F 9D 50 C1 CA 10 F2 88 D0 D1 E0 14 F0
06 E8 BD 4F C1 F0 F6 09 30 99 4F C1 C8 E8 E0 15 F0 05 BD 4F C1 90 F0 A9 00 99
4F C1 A9 4F A0 C1 4C 1E AB

ऑनलाइन डेमो

त्रुटि जाँच के साथ ऑनलाइन डेमो (346 बाइट्स)

उपयोग: sys49152,[n] जैसे sys49152,911188917558917।

समय प्रतिबंध और परीक्षण-मामलों को 64 बिट संख्या में गणना करने के लिए समाधान की आवश्यकता होती है, इसलिए C64 को " आधुनिक मशीन " के रूप में साबित करने का समय ;)

बेशक, इस कोड की काफी जरूरत है, ओएस 16bit से अधिक पूर्णांकों के लिए कुछ भी प्रदान नहीं करता है । यहाँ लंगड़ा हिस्सा: यह अभी तक NofP के एल्गोरिथ्म सम्मान का एक और कार्यान्वयन (थोड़ा संशोधित) है । xnor का बेहतर संस्करण । विचार के लिए धन्यवाद;)

व्याख्या

यहाँ एल्गोरिथ्म कर रही प्रासंगिक भाग की एक असंतुष्ट सूची की टिप्पणी की गई है:

.C:c06c  A2 0F       LDX #$0F           ; 15 bytes to clear
.C:c06e  A9 00       LDA #$00
.C:c070   .clearloop:
.C:c070  9D 3F C1    STA .num_a,X
.C:c073  CA          DEX
.C:c074  D0 FA       BNE .clearloop
.C:c076  A9 01       LDA #$01           ; initialize num_a and num_b
.C:c078  8D 3F C1    STA .num_a         ; to 1
.C:c07b  8D 47 C1    STA .num_b
.C:c07e  A2 08       LDX #$08           ; 8 bytes of input to check,
.C:c080   .findmsb:                     ; start at most significant
.C:c080  CA          DEX
.C:c081  BD 64 C1    LDA .nc_num,X
.C:c084  F0 FA       BEQ .findmsb       ; repeat until non-0 byte found
.C:c086  A0 09       LDY #$09           ; 8 bits to check (+1 for pre dec)
.C:c088   .findbit:
.C:c088  1E 64 C1    ASL .nc_num,X      ; shift left, highest bit to carry
.C:c08b  88          DEY
.C:c08c  90 FA       BCC .findbit       ; bit was zero -> repeat
.C:c08e  B0 0A       BCS .loopentry     ; jump into calculation loop
.C:c090   .mainloop:
.C:c090  CA          DEX                ; next byte
.C:c091  30 28       BMI .done          ; index -1? -> done calculating
.C:c093  A0 08       LDY #$08           ; 8 bits to check
.C:c095   .bitloop:
.C:c095  1E 64 C1    ASL .nc_num,X      ; shift left, highest bit to carry
.C:c098  90 04       BCC .tgt_b         ; if 0, store addition result in num_b
.C:c09a   .loopentry:
.C:c09a  A9 47       LDA #$47
.C:c09c  B0 02       BCS .tgt_a         ; ... else store in num_a ...
.C:c09e   .tgt_b:
.C:c09e  A9 4F       LDA #$4F
.C:c0a0   .tgt_a:
.C:c0a0  8D AF C0    STA $C0AF          ; ... using self-modification.
.C:c0a3  86 FE       STX $FE            ; save byte index
.C:c0a5  A2 F8       LDX #$F8           ; index for adding
.C:c0a7  18          CLC
.C:c0a8   .addloop:
.C:c0a8  BD 47 C0    LDA $C047,X        ; load byte from num_a
.C:c0ab  7D 4F C0    ADC $C04F,X        ; add byte from num_b
.C:c0ae  9D 47 C0    STA $C047,X        ; store to num_a or num_b
.C:c0b1  E8          INX                ; next index
.C:c0b2  D0 F4       BNE .addloop       ; done if index overflown
.C:c0b4  A6 FE       LDX $FE            ; restore byte index
.C:c0b6  88          DEY                ; decrement bit index
.C:c0b7  D0 DC       BNE .bitloop       ; bits left in current byte -> repeat
.C:c0b9  F0 D5       BEQ .mainloop      ; else repeat main loop
.C:c0bb   .done:
.C:c0bb  A2 F8       LDX #$F8           ; index for adding
.C:c0bd   .addloop2:
.C:c0bd  BD 47 C0    LDA $C047,X        ; load byte from num_a
.C:c0c0  7D 4F C0    ADC $C04F,X        ; add byte from num_b
.C:c0c3  9D 6C C0    STA $C06C,X        ; store to nc_num (result)
.C:c0c6  E8          INX                ; next index
.C:c0c7  D0 F4       BNE .addloop2      ; done if index overflown
.C:c0c9  AD 64 C1    LDA .nc_num        ; load least significant result byte
.C:c0cc  E9 01       SBC #$01           ; subtract 2 (1 + negated carry)
.C:c0ce  8D 64 C1    STA .nc_num        ; store least significant result byte
.C:c0d1  A2 F9       LDX #$F9           ; index for subtract
.C:c0d3   .subloop:
.C:c0d3  BD 6C C0    LDA $C06C,X        ; subtract 0 from all other bytes
.C:c0d6  E9 00       SBC #$00           ; for handling carry if necessary
.C:c0d8  9D 6C C0    STA $C06C,X
.C:c0db  E8          INX
.C:c0dc  D0 F5       BNE .subloop

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

— फेलिक्स पालमेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.