กำหนดรูปแบบ (สตริงหรือรูปแบบอาร์เรย์) ของ Bits: [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

เกณฑ์การชนะ: Codegolf

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

Haskellขนาด 15 ไบต์

scanl1$(*).succ

ลองออนไลน์!

คำอธิบาย / Ungolfed

scanl1 วนซ้ำจากซ้ายไปยังรายการโดยใช้ฟังก์ชันซึ่งรับผลลัพธ์สุดท้ายและองค์ประกอบปัจจุบันสร้างรายการใหม่พร้อมผลลัพธ์โดยปล่อยให้รายการว่างเปล่าและซิงเกิลตัน "ไม่ได้แก้ไข"

(*).succ เท่ากับ \x y-> (x+1)*y

การใช้ฟังก์ชั่นนั้นร่วมกับการscanl1ทำงานเพียงอย่างเดียวเนื่องจากลำดับที่เพิ่มขึ้น ( 1,2,3, .. ) เริ่มต้นด้วย1และไม่มีองค์ประกอบก่อนหน้า (ในกรณีนี้มันเป็นองค์ประกอบแรกในรายการที่จะไม่ถูก "แก้ไข") หรือพวกเขาได้เป็นผู้นำ0

Python 2 , 36 ไบต์

c=0
for i in input():c=c*i+i;print c

ลองออนไลน์!

Husk , 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]

แก้ไขประวัติ

^{-1 ไบต์โดยใช้scanl1มากกว่าzipWith}

^{-1 ไบต์โดย porting เดนนิส 's วิธีการแก้ปัญหา}

APL (Dyalog Unicode) 5 ไบต์

⊥⍨¨,\

ลองออนไลน์!

มันทำงานอย่างไร

⊥⍨¨,\
   ,\  ⍝ Convert to lists of first n elements
⊥⍨¨    ⍝ Map "Count trailing ones" to each list

JavaScript (ES6), 22 ไบต์

รับอินพุตเป็นอาร์เรย์

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

ลองออนไลน์!

a=>a.map(n=>a=n*-~a)น่าเสียดายที่สั้นกว่า(20 ไบต์) น่าเสียดายที่จะล้มเหลว[1]เนื่องจากมีการบังคับอาร์เรย์แบบซิงเกิลให้เป็นจำนวนเต็มที่พวกมันถืออยู่

J , 4 ไบต์

#.~\

พอร์ตของโซลูชัน APL ของ Bubbler

ลองออนไลน์!

J , 8 ไบต์

i.&0@|.\

อย่างไร?

มันเป็นแค่ระยะทางจากก่อนหน้า 0

       \  for each prefix
     |.   reverse it
    @     and
i.&0      find the index of the first 0

ลองออนไลน์!

Python 2 , 39 38 ไบต์

^{-1 ไบต์ขอบคุณ Erik the Outgolfer}

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

ลองออนไลน์!

เยลลี่ขนาด 4 ไบต์

‘×¥\

ลองออนไลน์!

‘×¥\
   \   Accumulate the input with:
  ¥   The dyad
‘      Increment the left element
 ×    Multiply by the second element (1 or 0)
       The result always begins with the first element unchanged

K (OK) , 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

เยลลี่ขนาด 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.

R , 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

RAD, 8 ไบต์

(⊢×1+⊣)⍂

ลองออนไลน์!

อย่างไร?

• (⊢×1+⊣)ถ้าอาร์กิวเมนต์ที่ถูกต้องคือ0ส่งกลับ0มิฉะนั้นจะเพิ่มอาร์กิวเมนต์ซ้าย
• ⍂, LTR Scan ( (A f B) f CแทนA f (B f C)) ใช้สิ่งนี้กับอาร์เรย์

Japt, 7 6 5 ไบต์

åÏ*°X

ลองมัน

คำอธิบาย

åÏ        :Cumulatively reduce
   °X     :  Increment the current total (initially 0)
  *       :  Multiply by the current element

Java 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`

TIS , 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

ไกอา 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

_{ฮึฉันคิดว่าแบบอักษร SE เป็นแบบ monospace ....}

C (gcc) , 45 44 38 ไบต์

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

ลองออนไลน์!

บันทึกหนึ่งไบต์ด้วย Toby Speight!

บันทึก 6 ไบต์โดยใช้ * = และเงื่อนไขชาญฉลาดในขณะที่

Perl 6 , 29 24 18 ไบต์

-6 ไบต์ขอบคุณ Sean!

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

ลองออนไลน์!

ฟังก์ชั่นภายในได้โดย($+=1)*=*แต่จากนั้นตัวแปรที่ไม่ระบุชื่อจะยังคงมีอยู่ในการเรียกใช้ฟังก์ชัน เราได้มาโดยการห่อมันไว้ในบล็อครหัสที่ชัดเจน

คำอธิบาย:

*.map:               # Map the array to
      {($+=1)    }   # The anonymous variable incremented
             *=$_    # Multiplied by the element

เยลลี่ 5 ไบต์

ṛȧ+ɗ\

ลองออนไลน์!

Haskell , 19 ไบต์

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

ลองออนไลน์!

คำอธิบาย: รหัสเทียบเท่ากับscanl1(\b a->(b+a)*a)โดยที่bบิตปัจจุบันและaเป็นตัวสะสม scanl1ใช้รายการยกตัวอย่างองค์ประกอบรายการแรกเป็นตัวสะสมและพับรายการและรวบรวมค่ากลางในรายการใหม่

แก้ไข: BMO ชนะฉันโดยไม่กี่วินาทีและ 4 ไบต์

Pyth , 6 ไบต์

m=Z*hZ

ลองที่นี่!

มันทำงานอย่างไร

m = Z * hZ - โปรแกรมเต็มรูปแบบ Q = อินพุตที่ได้รับการประเมิน
m - สำหรับแต่ละจำนวนเต็ม d ใน Q
 = Z - กำหนดตัวแปร Z (preinitialised เป็น 0) ให้กับ ...
   * hZ - (Z + 1) * d; (d หมายถึงตอนท้าย)

ต้องการรับคำตอบในการใช้นิพจน์ทั่วไป อาจมีวิธีแก้ปัญหาที่ง่ายกว่าที่ฉันทิ้งไว้เพื่อเป็นการออกกำลังกายสำหรับผู้อ่าน

PowerShell Core , 86 ไบต์

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

ลองออนไลน์!

ภาษา Wolfram (Mathematica)ขนาด 16 ไบต์

FoldList[+###2&]

ลองออนไลน์!

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ก็จะเป็น lexicographically >=สตริง"1"; ถ้ามันเริ่มต้นด้วย a 0มันจะไม่เป็นเช่นนั้น ดังนั้นbได้รับ0ถ้าตัวละครที่ดัชนีiเป็น0หรือถ้าตัวอักษรเป็น-11

vต่อไปเราจะปรับปรุงค่าปัจจุบัน หากเราเพิ่งอ่านก0เราต้องการvเป็น0; มิฉะนั้นเราต้องการเพิ่มขึ้นทีละvหนึ่ง ในคำอื่น ๆv = (-b) * (v+1); การทำให้คณิตศาสตร์ง่ายขึ้นให้นิพจน์สั้นลงที่เห็นในโค้ด ในที่สุดเราพิมพ์vและวนรอบ

Brain-Flakขนาด 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

เรติน่า 14 ไบต์

rv`0|(1)+
$#1¶

ลองออนไลน์!

C (gcc), 57 52 51 ไบต์

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

คำตอบจาวาสคริปต์ของ Port of Arnauldปรับเปลี่ยนอาร์เรย์ในสถานที่ ลองออนไลน์ได้ที่นี่

เช็คสเปียร์, 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.

ลองที่นี่

รุ่น golfed น้อย

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

C ++, 47 ไบต์

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

แลมบ์ดาที่ปรับเปลี่ยนอาเรย์ให้พอยน์เตอร์เริ่มต้นและสิ้นสุด

ลองออนไลน์! (ต้องใช้ Javascript)

รุ่นทั่วไปที่ 55 ไบต์ (ใช้งานได้กับคอนเทนเนอร์ที่มีองค์ประกอบประเภทคณิตศาสตร์):

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