लगातार 1-बिट्स बढ़े हुए हैं

36

बिट्स के एक पैटर्न (स्ट्रिंग या सरणी प्रारूप) को देखते हुए: [0,1,1,1,0,1,1,0,0,0,1,1,1,1,1,1]

कार्यों को 1 से शुरू होने वाले आरोही संख्या अनुक्रम के साथ लगातार 1-बिट्स की किसी भी संख्या को बदलना है।

इनपुट

  • पैटर्न (एक स्ट्रिंग या सरणी के रूप में प्राप्त किया जा सकता है) उदाहरण:
    • स्ट्रिंग: 1001011010110101001
    • सरणी: [1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1]

उत्पादन

  • आरोही संख्या अनुक्रम (एक स्ट्रिंग या सरणी के रूप में लौटाया जा सकता है) उदाहरण:
    • स्ट्रिंग: 1 0 0 1 0 1 2 0 1 0 1 2 0 1 0 1 0 0 1
    • सरणी: [1, 0, 0, 1, 0, 1, 2, 0, 1, 0, 1, 2, 0, 1, 0, 1, 0, 0, 1]

नियम

  • (केवल स्ट्रिंग्स के लिए आवेदन करें) इनपुट अभ्यस्त के बीच रिक्त स्थान होते हैं 1और0
  • इनपुट मान लें length > 0
  • (केवल स्ट्रिंग्स के लिए आवेदन करें) आउटपुट को अंतरिक्ष द्वारा अलग किया जाता है (किसी अन्य विभाजक का उपयोग करें यदि आपको तब तक आवश्यकता है जब तक कि वर्णमाला से कोई संख्या या अक्षर नहीं है)

उदाहरण: 

Given [0,1,1,1,0,1,1,0,0,0,1,1,1,1,1,1] 
Output [0,1,2,3,0,1,2,0,0,0,1,2,3,4,5,6]

--------------------------------------------------------------------------

Given 0110101111101011011111101011111111     
Output 0 1 2 0 1 0 1 2 3 4 5 0 1 0 1 2 0 1 2 3 4 5 6 0 1 0 1 2 3 4 5 6 7 8

---------------------------------------------------------------------------

Given 11111111111101    
Output 1 2 3 4 5 6 7 8 9 10 11 12 0 1

जीत के मापदंड: कोडगोल्फ

code-golf  sequence 
— लुइस फेलिप डी जीसस मुनोज
स्रोत

जवाबों:

19

05AB1E , 4 बाइट्स

γ€ƶ˜

इसे ऑनलाइन आज़माएं! या एक परीक्षण सूट के रूप में

व्याख्या

γ      # split input into groups of consecutive equal elements
 €ƶ    # multiply each number in each sublist by its 1-based index in the sublist
   ˜   # flatten
— Emigna
स्रोत
1
उफ, मेरी तुलना में बेहतर है। मैंने ऐसा कभी नहीं सोचा होगा।
— मैजिक ऑक्टोपस Urn
3
मैं कोडगॉल्फ बाइट-काउंटिंग नियमों से 100% परिचित नहीं हूं (और गुग्लिंग ने केवल इस पोस्ट को पाया जो किसी निष्कर्ष पर नहीं आया था)। जबकि आपका उत्तर 4 अक्षर है, यह कम से कम 8 बाइट्स नहीं होना चाहिए (जैसे, utf-16- बीओएम के बिना 03 B3 20 AC 01 B6 02 DC) या 9 बाइट्स (utf-8:) CE B3 E2 82 AC C6 B6 CB 9Cया 10 बाइट्स (जैसे, UTF-16 जिसमें 2 बाइट बॉम शामिल हैं) किसी भी गैर-खिलौना एन्कोडिंग में? (हां, एक 1-बाइट के रूप में प्रतिनिधित्व इन 4 प्रतीकों के साथ iso-8859 एन्कोडिंग के समान एक खिलौना 8-बिट एन्कोडिंग का निर्माण कर सकता है , लेकिन यह धोखा जैसा लगता है।)
— jimbob
6
@drjimbob हां, अच्छा सवाल। कोड को वास्तव में 05AB1E कोड पेज का उपयोग करके एक बाइनरी फ़ाइल में परिवर्तित किया जा सकता है । उदाहरण के लिए, के γ€ƶ˜रूप में प्रतिनिधित्व किया जाएगा 04 80 8F 98। कोड पेज मुख्य रूप से लेखन कोड को आसान बनाने के लिए मौजूद है। इस 4-बाइट फ़ाइल को चलाने के लिए, आपको --osabieध्वज के साथ दुभाषिया चलाना होगा ।
— अदनान
18

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

scanl1$(*).succ

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

स्पष्टीकरण / Ungolfed

scanl1 एक फ़ंक्शन का उपयोग करके एक सूची में बाईं ओर से पुनरावृत्ति होती है जो अंतिम परिणाम लेती है और वर्तमान तत्व परिणामों के साथ एक नई सूची उत्पन्न करता है, खाली सूची और एकल "अनमॉडिफाइड" छोड़ देता है।

(*).succ के बराबर है \x y-> (x+1)*y

उस फ़ंक्शन का उपयोग scanl1केवल एक साथ काम करता है क्योंकि बढ़ते अनुक्रम ( 1,2,3, .. ) 1 से शुरू होते हैं और या तो कोई पूर्ववर्ती तत्व नहीं होता है (इस मामले में यह सूची में पहला तत्व है जो "संशोधित" नहीं होगा) या उनके पास एक अग्रणी 0 है ।

— ბიმო
स्रोत
14

भूसी , 5 4 3 बाइट्स

ṁ∫g

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

व्याख्या

ṁ∫g  -- full function, example input: [1,1,1,0,1]
  g  -- group: [[1,1],[0],[1]]
ṁ    -- map the following and concatenate result (example with [1,1,1])
 ∫   -- | cumulative sum: [1,2,3]
     -- : [1,2,3,0,1]

इतिहास संपादित करें

scanl1ओवर का उपयोग करके -1 बाइटzipWith

डेनिस के समाधान को चित्रित करके -1 बाइट

— ბიმო
स्रोत
11

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

एक सरणी के रूप में इनपुट लेता है।

a=>a.map(s=n=>s=n*-~s)

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

छोटे a=>a.map(n=>a=n*-~a)(20 बाइट्स) दुर्भाग्य [1]से सिंगलटन सरणियों के जबरदस्ती के कारण असफल हो जाते हैं, जब वे धारण किए हुए पूर्णांक तक होते हैं।

— Arnauld
स्रोत
8

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

-1 बाइट थैंक्स टू एरिक द आउटगोलर

i=1
for x in input():i*=x;print i;i+=1

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

— छड़ी
स्रोत
1
मुझे नहीं लगता कि आपको इसकी आवश्यकता है ,।
— १g पर आउटगॉल्फर एरिक
@EriktheOutgolfer यह इस तरह से सुंदर लगती है c:
— Rod
1
क्षमा करें, लेकिन कभी-कभी, जीवन में, आपको बलिदान करना पड़ता है।
— आउटगॉल्फ
9
RIP ,आप अब कोड में नहीं हैं, लेकिन आप हमेशा मेरे दिल में रहेंगे
— Rod
6

के (ओके) , 11 8 बाइट्स

समाधान:

{y*1+x}\

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

स्पष्टीकरण:

सूची में दर्ज करें। वृद्धि संचायक, वर्तमान आइटम से गुणा (जो आइटम 0 है, तो संचायक को रीसेट करता है):

{y*1+x}\ / the solution
{     }\ / iterate (\) over lambda function
     x   / accumulator
   1+    / add 1
 y*      / multiply by current item
— streetster
स्रोत
5

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

ŒgÄF

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

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

ŒgÄF  Main link. Argument: A (bit array)

Œg    Group adjacent, identical bits.
  Ä   Accumulate; take the cumulative sum of each chunk.
   F  Flatten.
— डेनिस
स्रोत
तेजी से समूह रन के साथ एरिक ने सुझाव दिया था कि यह तीन बाइट्स होगा! (अगर मैं समझ गया कि यह सही ढंग से क्या करेगा)
— डायलेन
@dylnan समस्या यह है कि इस तरह के एक त्वरित व्यवहार के बारे में फैसला करना मुश्किल है। :( यही कारण है कि त्वरित अभी भी अंतराल में है।
— एरिक आउटगोल्फर
मुख्य संभावित कार्यान्वयन के लिए कई
— क्विक
5

आर , 46 31 बाइट्स

function(a)sequence(rle(a)$l)*a

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

sequence, जो "आर के बहुत प्रारंभिक इतिहास में मुख्य रूप से श्रद्धा में मौजूद है" , यहां काफी उपयोगी है।

function(a)                       # function, taking a vector as argument
                    rle(a)$l      # take the lengths of the run-length encoding
           sequence(        )     # and generate the list [1:x for x in lengths]
                             *a   # multiply by a to maintain 0s, and return
— ग्यूसेप
स्रोत
5

राड, 8 बाइट्स

(⊢×1+⊣)⍂

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

कैसे?

  • (⊢×1+⊣), अगर सही तर्क है 0, वापस लौटें 0, अन्यथा बाएं तर्क को बढ़ाएं
  • ⍂, LTR Scan (के (A f B) f Cस्थान पर A f (B f C)), इसे सरणी में लागू करें
— जाकारी
स्रोत
4

जावा 8, 55 48 बाइट्स

a->{int p=0,i=0;for(int v:a)a[i++]=v<1?p=0:++p;}

बाइट को बचाने के लिए एक नया वापस करने के बजाय इनपुट-सरणी को संशोधित करता है।

-7 बाइट्स @TimSeguine का धन्यवाद ।

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

स्पष्टीकरण:

a->{             // Method with integer-array parameter and no return-type
  int p=0,       //  Previous integer, starting at 0
      i=0;       //  Index-integer, starting at 0
  for(int v:a)   //  Loop over the values of the input-array:
    a[i++]=v<1?  //   If the current value is 0:
          p=0    //    Reset the previous integer to 0
         :       //   Else:
          ++p;}  //    Increase `p` by 1 first with `++p`
                 //    and set the current item to this new value of `p`
— केविन क्रूज़सेन
स्रोत
1
आप इसे 48 तक शेव कर सकते हैं:a->{int p=0,i=0;for(int b:a)a[i++]=b<1?p=0:++p;}
— टिम सेगिन
@TimSeguine धन्यवाद! अब जब मैं देख रहा हूं तो मुझे विश्वास नहीं हो रहा है कि मैंने इसके बारे में खुद नहीं सोचा था।
— केविन क्रूज़सेन
1
मैं पी से छुटकारा पाने में सक्षम था, लेकिन यह एक ही आकार है :(a->{int i=0;for(int v:a)a[i]+=v*i++<1?0:a[i-2];}
— टिम सेगिन
4

टीआईएस , 68 + 33 = 101 बाइट्स

कोड (68 बाइट्स):

@0
MOV UP ACC
SUB 47
MOV ACC ANY
@1
ADD 1
JRO UP
SUB ACC
MOV ACC ANY

लेआउट (33 बाइट्स):

2 1 CC I0 ASCII - O0 NUMERIC - 32

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

स्पष्टीकरण:

|    Input 0    |    Input is given in ASCII (`0` is 48, `1` is 49)
+--------+------+
| Node 0 |      |    This node prepares the input data
+--------+      |
| MOV UP ACC    |    Read in a character
| SUB 47        |    Subtract 47 to map [48, 49] to [1, 2]
| MOV ACC ANY   |    Send the 1 or 2 to the next node
|               |    Implicitly wrap back to top of node
+--------+------+
| Node 1 |      |    This node does the incrementing/printing
+--------+      |
| ADD 1         |    Increment counter (starts at zero)
| JRO UP        |    Get value from above, and jump forward that many lines  (skip next line or not)
| SUB ACC       |    Reset counter to zero (if input was zero)
| MOV ACC ANY   |    Send the counter value downward to be printed
|               |    Implicitly wrap back to top of node
+---------------+
|   Output 0    |    Output is space-delimited numeric values
— Phlarx
स्रोत
4

गैया , 5 बाइट्स

ẋ+⊣¦_

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

व्याख्या

ẋ+⊣¦_     Full program
ẋ         Split into chunks of equal adjacent values.
   ¦_     And for each chunk, flattening the result afterwards...
 +⊣       Reduce it cumulatively on + (addition); aka cumulative sums

उह, मुझे लगा कि एसई कोड फोंट मोनोस्पेस थे ...।

— मिस्टर एक्सकोडर
स्रोत
वे मोनोस्पेस हैं ... पहली पंक्ति में एक स्थान गायब है।
— माइकल जूल
संपादन को देखो। यह अभी भी गलत है।
— श्री एक्सकोडर
आप मोबाइल डिवाइस या किसी चीज़ से देख रहे होंगे - यह मुझे ठीक लगता है
— micsthepick
— श्री Xcoder
4

सी (जीसीसी) , 45 44 38 बाइट्स

f(a,i)int*a;{while(--i)*++a*=-~a[-1];}

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

टोबी स्पाइट के लिए एक बाइट धन्यवाद बचाओ!

6 = बाइट्स का उपयोग करके बचाएं * और हालत के दौरान एक स्मार्ट।

— मतेज मुलज
स्रोत
आप 1 बाइट बचा सकते हैं: *(a-1)→a[-1]
— टोबे स्पाइट
PPCG में आपका स्वागत है! :)
— झबरा
4

पर्ल 6 , 29 24 18 बाइट्स

सीन करने के लिए -6 बाइट्स धन्यवाद!

*.map:{($+=1)*=$_}

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

द्वारा आंतरिक कार्य कर सकता है ($+=1)*=* , लेकिन तब अनाम चर फ़ंक्शन कॉल में जारी रहेगा। हम इसे एक स्पष्ट कोड ब्लॉक में लपेटकर प्राप्त करते हैं।

स्पष्टीकरण:

*.map:               # Map the array to
      {($+=1)    }   # The anonymous variable incremented
             *=$_    # Multiplied by the element
— मजाक कर रहा है
स्रोत
मुझे 16 बाइट्स के नीचे एक ही मूल दृष्टिकोण मिला *.map(($+=1)*=*):। इस समाधान में यह साबित होता है कि स्टेट वैरिएबल $फ़ंक्शन पर कॉल के लिए बना रहता है, इसलिए यदि अंतिम तत्व एक कॉल में पास हो जाता है और पहला कॉल अगली कॉल के लिए पास हो जाता है, तो दोनों नॉनज़रो होते हैं, फिर गिनती गलत नंबर से शुरू होगी।
— शॉन
@ सीन, हाँ मुझे याद है कि जब मैंने मूल रूप से उत्तर दिया था, तो उसके साथ संघर्ष कर रहा था। सौभाग्य से मैंने उसके बाद से एक तरीका सीखा है
— जो किंग
आप एक और बाइट को बंद कर सकते हैं *.map:{...}:।
— सीन
3

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

scanl1$((*)=<<).(+)

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

स्पष्टीकरण: कोड के बराबर है scanl1(\b a->(b+a)*a), जहां bवर्तमान बिट है और aसंचायक है।scanl1एक सूची लेता है, संचयकर्ता के रूप में पहली सूची तत्व को तात्कालिक करता है, और सूची पर फोल्ड करता है और एक नई सूची में मध्यवर्ती मान एकत्र करता है।

संपादित करें: BMO ने मुझे कुछ सेकंड और 4 बाइट्स से हराया ।

— Laikoni
स्रोत
3

अजगर , 6 बाइट्स

m=Z*hZ

यहाँ यह कोशिश करो!

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

m = Z * hZ - पूर्ण कार्यक्रम। Q = मूल्यांकित इनपुट।
m - Q में प्रत्येक पूर्णांक d के लिए।
 = Z - चर Z को असाइन करें (0 से पूर्वनिर्मित)
   * hZ - (Z + 1) * d; (d अंत में निहित है)।
— मिस्टर एक्सकोडर
स्रोत
3

नियमित भावों का उपयोग करके उत्तर प्राप्त करना चाहते थे। शायद एक आसान समाधान है जिसे मैं पाठक के लिए एक अभ्यास के रूप में छोड़ता हूं।

पॉवरशेल कोर , 86 बाइट्स

Filter F{($_-split"(0)(\B|\b)"|?{$_-ne''}|%{$_-replace'(1+)',(1..$_.Length)})-join' '}

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

— जेफ फ्रीमैन
स्रोत
3

QBasic, 60 बाइट्स

INPUT s$
FOR i=1TO LEN(s$)
b=MID$(s$,i)>="1
v=-b*v-b
?v
NEXT

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

व्याख्या

हम स्ट्रिंग पढ़ने s$और पाश iसे 1इसकी लंबाई पर निर्भर है।

MID$(s$,i)स्ट्रिंग iके अंत में वर्ण (1-अनुक्रमित) से सबस्ट्रिंग मिलता है । यदि यह ए से शुरू होता है 1, तो यह शाब्दिक रूप >=से स्ट्रिंग होगा "1"; यदि यह एक के साथ शुरू होता है 0, तो यह नहीं होगा। तो bहो जाता है 0, तो सूचकांक में चरित्र iहै 0, या -1अगर चरित्र है 1।

अगला, हम वर्तमान मूल्य को अपडेट करते हैं v। यदि हम अभी पढ़ते हैं 0, तो हम बनना चाहते vहैं 0; अन्यथा, हम एक से बढ़ाना चाहते हैं v। दूसरे शब्दों में v = (-b) * (v+1); गणित को सरल बनाने से कोड में देखी गई छोटी अभिव्यक्ति मिलती है। अंत में, हम प्रिंट vऔर लूप करते हैं।

— DLosc
स्रोत
3

ब्रेन-फ्लैक , 60 बाइट्स

([]){{}<>(())<>{{}<>({}({}))(<>)}{}([])}{}<>{({}[()]<>)<>}<>

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

स्पष्टीकरण:

([]){  For each element in the input
    {}
    <>(())<>  Push a one to the other stack
    { If the element is one,
       {}<>({}({}))(<>)  Add the one to a copy of the previous number in the series
    }{}  Pop the element
([])}  End loop
{}<>   Pop extra zero
{({}[()]<>)<>}<>   And reverse the output stack, subtracting one from each element
— मजाक कर रहा है
स्रोत
3

सी (जीसीसी), 57 52 51 बाइट्स

f(a,l,c,i)int*a;{for(c=i=0;i<l;)a[i++]=c=a[i]*-~c;}

पोर्ट ऑफ़ अरनल्ड्स जावास्क्रिप्ट उत्तर , सरणी को जगह में संशोधित करता है। इसे यहाँ ऑनलाइन आज़माएँ ।

— OOBalance
स्रोत
क्या यह कहना अधिक सटीक नहीं होगा कि यह K & R C है?
— टिम सेगिन
संभवतः, लेकिन यह बहुत सारे जवाबों का सच होगा। मैं कोई विशेषज्ञ नहीं हूं, लेकिन यह पूरी तरह से संभव है कि यह K & R C. भी मान्य न हो। बात यह है, हम वास्तव में इस साइट पर भाषा के मानकों की परवाह नहीं करते हैं। यदि gcc आपको K & R C को और अधिक आधुनिक सामान के साथ मिलाने की अनुमति देता है, तो यह गोल्फ के प्रयोजनों के लिए मान्य C है क्योंकि gcc इसे तैयार करेगा। इन्हें भी देखें: codegolf.stackexchange.com/questions/2203/tips-for-golfing-in-c
— OOBalance
मुझे अब तक यह पता नहीं चला है कि C11 अभी भी पुराने पहचानकर्ता सूची फ़ंक्शन सिंटैक्स का समर्थन करता है, इसलिए कोई बात नहीं। लेकिन आपकी बात की परवाह किए बिना।
— टिम सेगिन
1
सुझावf(a,l,c)int*a;{for(c=0;l--;)c=*a++*=c+1;}
3

शेक्सपियर, 365 बाइट्स

I.Ajax,.Ford,.Act I:.Scene I:.[enter Ajax and Ford]Ajax:Open mind!Scene V:.Ford:Am I nicer than the sum of a big red old cute hard cat a big red old cute joy?Ford:If so,you is the sum of thyself a son!Ford:If not,you is zero!Ford:Open heart!Ajax:you is a big red old cute hard cat.Ajax:Speak mind!Ajax:Open mind!Ford:Am I nicer than zero?Ajax:If so, let us Scene V.

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

कम गोल्फ संस्करण

I.Ajax,.Ford,.
Act I:.
Scene I:.
[enter Ajax and Ford]
Ajax:Open mind!
Scene V:.
Ford:Am I nicer than the sum of a big red old cute hard cat a big red old cute joy?     <- smallest way to 48 (ascii "0") I could think of
Ford:If so,you is the sum of thyself a son!
Ford:If not,you is zero!
Ford:Open heart!
Ajax:you is a big red old cute hard cat.    <- get value of 32 or space
Ajax:Speak mind!                            <- then output it
Ajax:Open mind!
Ford:Am I nicer than zero?
Ajax:If so, let us Scene V.                 <- loop through inputs
— अल आर
स्रोत
280 बाइट्स । की जाँच करें SPL सुझावों पेज सुझावों गोल्फ के लिए।
— जो किंग
3

सी ++, 47 बाइट्स

[](int*a,int*b){for(int c=0;a!=b;)c=*a++*=1+c;}

एक लैम्ब्डा जो जगह में एक सरणी को संशोधित करता है, जो प्रारंभ और अंत संकेत देता है।

इसे ऑनलाइन आज़माएं! (जावास्क्रिप्ट की आवश्यकता है)

55 बाइट्स पर जेनेरिक संस्करण (यह अंकगणित प्रकार के तत्वों के साथ किसी भी कंटेनर के लिए काम करता है):

[](auto a,auto b){for(auto c=*a-*a;a!=b;)c=*a++*=1+c;};
— टोबी स्पाईट
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.