给定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

在线尝试！

解释/取消

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

在线尝试！

外壳，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移植字节丹尼斯的溶液}

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个字节

#.~\

Bubbler的APL解决方案的移植

在线尝试！

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在这里非常方便，它“主要与R的早期历史有关”。

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

_{gh，我以为SE代码字体是等宽字体。}

C（gcc），45 44 38字节

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

在线尝试！

多亏Toby Speight节省了一个字节！

使用* =和更聪明的while条件可节省6个字节。

Perl 6的，29个24 18字节

-6个字节，感谢肖恩！

*.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 –对于Q中的每个整数d。
 = Z –将变量Z（预初始化为0）分配给...
   * hZ –（Z +1）* d; （d在末尾是隐式的）。

想要获得使用正则表达式的答案。我可能有一个更简单的解决方案，留给读者练习。

PowerShell核心，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索引）到字符串结尾的子字符串。如果以a开头1，则在字典上>=是字符串"1"; 如果以a开头0，则不会。因此b得到0，如果在索引中的字符i是0，或-1如果人品1。

接下来，我们更新当前值v。如果我们只阅读a 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;}

Arnauld的JavaScript答案端口，就地修改了数组。在这里在线尝试。

莎士比亚，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

C ++，47个字节

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

给定开始和结束指针的lambda修改数组。

在线尝试！（需要Javascript）

通用版本为55个字节（适用于具有算术类型元素的任何容器）：

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