Cho một mẫu (định dạng chuỗi hoặc mảng) của Bits: [0,1,1,1,0,1,1,0,0,0,1,1,1,1,1,1]

Các tác vụ là thay thế bất kỳ số lượng 1-bit liên tiếp nào bằng một chuỗi số tăng dần bắt đầu từ 1.

Đầu vào

• Mẫu (có thể được nhận dưới dạng chuỗi hoặc mảng) Ví dụ:
  • Chuỗi: 1001011010110101001
  • Mảng: [1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1]

Đầu ra

• Chuỗi số tăng dần (có thể được trả về dưới dạng chuỗi hoặc mảng) Ví dụ:
  • Chuỗi: 1 0 0 1 0 1 2 0 1 0 1 2 0 1 0 1 0 0 1
  • Mảng: [1, 0, 0, 1, 0, 1, 2, 0, 1, 0, 1, 2, 0, 1, 0, 1, 0, 0, 1]

Quy tắc

• (chỉ áp dụng cho chuỗi) Đầu vào sẽ không chứa khoảng trắng giữa 1và0
• Giả sử đầu vào length > 0
• (chỉ áp dụng cho chuỗi) Đầu ra được phân tách bằng dấu cách (sử dụng bất kỳ dấu phân cách nào khác nếu bạn cần miễn là không phải là số hoặc chữ cái trong bảng chữ cái)

Thí dụ:

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

Tiêu chí chiến thắng: Codegolf

05AB1E , 4 byte

γ€ƶ˜

Hãy thử trực tuyến! hoặc như một bộ đồ thử nghiệm

Giải trình

γ      # 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 byte

scanl1$(*).succ

Hãy thử trực tuyến!

Giải thích / Ungolfed

scanl1 lặp lại từ bên trái một danh sách bằng cách sử dụng hàm lấy kết quả cuối cùng và phần tử hiện tại tạo ra một danh sách mới với kết quả, để lại danh sách trống và singletons "không thay đổi".

(*).succ tương đương với \x y-> (x+1)*y

Sử dụng chức năng đó cùng với scanl1chỉ hoạt động vì các chuỗi tăng dần ( 1,2,3, .. ) bắt đầu bằng 1 và không có phần tử nào trước đó (trong trường hợp đó là phần tử đầu tiên trong danh sách sẽ không được "sửa đổi") hoặc họ có 0 hàng đầu .

Python 2 , 36 byte

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

Hãy thử trực tuyến!

Husk , 5 4 3 byte

ṁ∫g

Hãy thử trực tuyến!

Giải trình

ṁ∫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]

Chỉnh sửa lịch sử

^{-1 byte bằng cách sử dụng scanl1hơnzipWith}

^{-1 byte bằng cách chuyển giải pháp của Dennis}

APL (Dyalog Unicode) , 5 byte

⊥⍨¨,\

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

JavaScript (ES6), 22 byte

Đưa đầu vào như một mảng.

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

Hãy thử trực tuyến!

Không may a=>a.map(n=>a=n*-~a)(20 byte) ngắn hơn sẽ không thành công [1]do ép buộc các mảng đơn lẻ với số nguyên mà chúng đang giữ.

J , 4 byte

#.~\

Một cổng của giải pháp APL của Bubbler's

Hãy thử trực tuyến!

J , 8 byte

i.&0@|.\

Làm sao?

Nó chỉ đơn giản là khoảng cách đến trước 0

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

Hãy thử trực tuyến!

Python 2 , 39 38 byte

^{-1 byte nhờ Erik the Outgolfer}

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

Hãy thử trực tuyến!

Thạch , 4 byte

‘×¥\

Hãy thử trực tuyến!

‘×¥\
   \   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 byte

Dung dịch:

{y*1+x}\

Hãy thử trực tuyến!

Giải trình:

Lặp lại danh sách. Bộ tích lũy tăng dần, nhân với mục hiện tại (sẽ đặt lại bộ tích lũy nếu mục bằng 0):

{y*1+x}\ / the solution
{     }\ / iterate (\) over lambda function
     x   / accumulator
   1+    / add 1
 y*      / multiply by current item

Thạch , 4 byte

ŒgÄF

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Œ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 byte

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

Hãy thử trực tuyến!

sequence, "chủ yếu tồn tại trong sự tôn trọng lịch sử rất sớm của R" , khá tiện dụng ở đây.

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 byte

(⊢×1+⊣)⍂

Hãy thử trực tuyến!

Làm sao?

• (⊢×1+⊣), nếu đối số bên phải là 0, trả về 0, nếu không thì tăng đối số bên trái
• ⍂, LTR Scan ( (A f B) f Cthay vì A f (B f C)), áp dụng điều này trên toàn mảng

Japt, 7 6 5 byte

åÏ*°X

Thử nó

Giải trình

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

Java 8, 55 48 byte

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

Sửa đổi mảng đầu vào thay vì trả về một mảng mới để lưu byte.

-7 byte nhờ @TimSeguine .

Hãy thử trực tuyến.

Giải trình:

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 byte

Mã (68 byte):

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

Bố cục (33 byte):

2 1 CC I0 ASCII - O0 NUMERIC - 32

Hãy thử trực tuyến!

Giải trình:

|    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

Gaia , 5 byte

ẋ+⊣¦_

Hãy thử trực tuyến!

Giải trình

ẋ+⊣¦_     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

_{Ugh, tôi nghĩ phông chữ SE là không gian ....}

C (gcc) , 45 44 38 byte

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

Hãy thử trực tuyến!

Tiết kiệm một byte nhờ Toby Speight!

Lưu 6 byte bằng cách sử dụng * = và thông minh hơn trong khi điều kiện.

Perl 6 , 29 24 18 byte

-6 byte nhờ Sean!

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

Hãy thử trực tuyến!

Các chức năng bên trong có thể bởi ($+=1)*=* , nhưng sau đó biến ẩn danh sẽ tồn tại trên các lệnh gọi hàm. Chúng tôi có được điều này bằng cách gói nó trong một khối mã rõ ràng.

Giải trình:

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

Thạch , 5 byte

ṛȧ+ɗ\

Hãy thử trực tuyến!

Haskell , 19 byte

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

Hãy thử trực tuyến!

Giải thích: Mã tương đương với scanl1(\b a->(b+a)*a), bbit hiện tại ở đâu và alà bộ tích lũy.scanl1lấy một danh sách, khởi tạo phần tử danh sách đầu tiên dưới dạng bộ tích lũy và gấp lại danh sách và thu thập các giá trị trung gian trong một danh sách mới.

Chỉnh sửa: BMO đánh bại tôi trong vài giây và 4 byte .

Bình thường , 6 byte

m=Z*hZ

Hãy thử nó ở đây!

Làm thế nào nó hoạt động

m = Z * hZ - Chương trình đầy đủ. Q = đầu vào được đánh giá.
m - Với mỗi số nguyên d trong Q.
 = Z - Gán biến Z (preinitialised thành 0) cho ...
   * hZ - (Z + 1) * d; (d là ẩn ở cuối).

Muốn có được một câu trả lời trong việc sử dụng các biểu thức thông thường. Có lẽ có một giải pháp dễ dàng hơn mà tôi để lại như một bài tập cho người đọc.

Lõi PowerShell , 86 byte

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 16 byte

FoldList[+###2&]

Hãy thử trực tuyến!

QBasic, 60 byte

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

Lấy đầu vào là một chuỗi; đưa ra đầu ra dưới dạng số được phân tách bằng dòng mới.

Giải trình

Chúng tôi đọc chuỗi s$và vòng lặp itừ 1chiều dài của nó.

MID$(s$,i)lấy chuỗi con từ ký tự i(1-index) đến cuối chuỗi. Nếu điều này bắt đầu bằng a 1, nó sẽ là từ vựng >=theo chuỗi "1"; nếu nó bắt đầu bằng a 0, nó sẽ không như vậy. Vì vậy, bnhận được 0nếu nhân vật tại chỉ mục ilà 0, hoặc -1nếu nhân vật là1 .

Tiếp theo, chúng tôi cập nhật giá trị hiện tại v. Nếu chúng ta chỉ đọc một 0, chúng ta muốn vtrở thành 0; mặt khác, chúng tôi muốn tăng thêm vmột. Nói cách khác , v = (-b) * (v+1); đơn giản hóa toán học cho biểu thức ngắn hơn được thấy trong mã. Cuối cùng, chúng tôi in vvà lặp.

Brain-Flak , 60 byte

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

Hãy thử trực tuyến!

Giải trình:

([]){  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

Võng mạc , 14 byte

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

Hãy thử trực tuyến!

C (gcc), 57 52 51 byte

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

Câu trả lời JavaScript của Port of Arnauld , sửa đổi mảng tại chỗ. Hãy thử trực tuyến tại đây .

Shakespeare, 365 byte

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.

thử nó ở đây

phiên bản ít chơi gôn

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 byte

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

Một lambda sửa đổi một mảng tại chỗ, con trỏ bắt đầu và kết thúc.

Hãy thử trực tuyến! (yêu cầu Javascript)

Phiên bản chung ở 55 byte (điều này hoạt động cho bất kỳ vùng chứa nào có các yếu tố thuộc loại số học):

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