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

하스켈 , 15 바이트

scanl1$(*).succ

온라인으로 사용해보십시오!

설명 / 비 골프

scanl1 마지막 결과와 현재 요소가 결과와 함께 새 목록을 생성하는 함수를 사용하여 목록에서 왼쪽부터 반복하여 빈 목록과 싱글 톤은 "수정되지 않은"상태로 둡니다.

(*).succ 는 \x y-> (x+1)*y

scanl1증가하는 시퀀스 ( 1,2,3, .. )는 1로 시작하고 선행 요소가 없기 때문에이 기능을 함께 사용할 수 있습니다 (이 경우 목록에서 첫 번째 요소가 "수정되지 않음") 또는 앞에 0이 있습니다.

파이썬 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]

기록 편집

^{scanl1over 를 사용하여 -1 바이트zipWith}

^{이식에 의해 -1 바이트 데니스 의 용액을}

APL (Dyalog Unicode) , 5 바이트

⊥⍨¨,\

온라인으로 사용해보십시오!

작동 원리

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

자바 스크립트 (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

온라인으로 사용해보십시오!

파이썬 2 , 39 38 바이트

^{Outgolfer Erik 덕분에 -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 스캔 ( (A f B) f C대신 A f (B f C))을 어레이에 적용

apt, 7 6 5 바이트

åÏ*°X

시도 해봐

설명

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

자바 8, 55 48 바이트

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

바이트를 절약하기 위해 새로운 것을 반환하는 대신 입력 배열을 수정합니다.

@TimSeguine 덕분에 -7 바이트 .

온라인으로 사용해보십시오.

설명:

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

Gaia , 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 덕분에 1 바이트를 절약하십시오!

* =와 더 똑똑한 조건을 사용하여 6 바이트를 절약하십시오.

펄 6 , 29 24 18 바이트

Sean 덕분에 -6 바이트!

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

온라인으로 사용해보십시오!

내부 함수는 by를 사용할 수 ($+=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 – 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 Language (Mathematica) , 16 바이트

FoldList[+###2&]

온라인으로 사용해보십시오!

Q 기본, 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". 로 시작 0하면 그렇지 않습니다. 그래서 b얻는 0인덱스에있는 문자가있는 경우 i이다 0, 또는 -1문자 인 경우 1.

다음으로 현재 값을 업데이트합니다 v. 우리는 단지를 읽는다면 0, 우리는 원하는 v되기 위해 0; 그렇지 않으면, 우리 v는 1 씩 증가시키고 싶습니다 . 즉, 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의 자바 스크립트 대답은 , 현재 위치에서 배열을 수정합니다. 여기에서 온라인으로 사용해보십시오 .

셰익스피어, 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;}

시작 및 끝 포인터가 주어지면 배열을 수정하는 람다.

온라인으로 사용해보십시오! (자바 스크립트 필요)

55 바이트의 일반 버전 (산술 유형의 요소가있는 모든 컨테이너에서 작동) :

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