Дано шаблон (формат рядка або масиву) Біт: [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 байт шляхом перенесення Dennis «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 байт завдяки Еріку Переможнику}

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`

ТИС , 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 коду є просторовими ....}

C (gcc) , 45 44 38 байт

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

Спробуйте в Інтернеті!

Збережіть один байт завдяки Toby Speight!

Збережіть 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 байт

ṛȧ+ɗ\

Спробуйте в Інтернеті!

Хаскелл , 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 (попередньо до 0) до ...
   * hZ - (Z + 1) * d; (d в кінці неявна).

Хотів отримати відповідь, використовуючи регулярні вирази. Напевно, є більш просте рішення, яке я залишаю як вправу для читача.

PowerShell Core , 86 байт

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

Спробуйте в Інтернеті!

Мова Вольфрама (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, це буде лексикографічно >=рядок "1"; якщо він починається з а 0, його не буде. Так bотримується, 0якщо символ в індексі iє 0, або -1якщо символ є 1.

Далі ми оновлюємо поточне значення v. Якщо ми просто читаємо а 0, ми хочемо vстати 0; інакше ми хочемо збільшити vпо одному. Іншими словами v = (-b) * (v+1),; спрощення математики дає коротший вираз, видно у коді. Нарешті, роздруковуємо vі петлю.

Мозок-Флак , 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;}

Відповідь 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;}

Лямбда, яка модифікує масив на місці, задані вказівки початку та кінця.

Спробуйте в Інтернеті! (потрібен Javascript)

Загальна версія на 55 байт (це працює для будь-якого контейнера з елементами арифметичного типу):

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