이것은 HP CodeWars의 최근 경쟁 의 문제 13-비 반복 바이너리 입니다 .

임의의 십진수를 봅시다.

727429805944311

이진 표현을 살펴보십시오.

10100101011001011111110011001011101010110111110111

이제 이진 표현을 숫자 0와 1번갈아가는 하위 시퀀스로 나눕니다 .

1010 010101 10 0101 1 1 1 1 1 10 01 10 0101 1 1010101 101 1 1 1 101 1 1

각 하위 시퀀스를 다시 십진수로 변환합니다.

10 21 2 5 1 1 1 1 1 2 1 2 5 1 85 5 1 1 1 5 1 1

작업

단일 양의 정수를 입력으로 사용하여 위의 프로세스에서 얻은 양의 정수 시퀀스를 출력하십시오.

세부

• 입력 및 출력은 10 진수 또는 단항이어야합니다.
• 출력의 숫자는 사람이 읽을 수있는 현명한 방식으로 분리되어야하며 십진수 또는 단항이어야합니다. 공백에는 제한이 없습니다. 유효 출력 스타일 : [1,2,3], 1 2 3, 1\n2\n3어디서 \n등 문자 뉴 라인이다

테스트 사례

 Input | Output
     0 | 0
     1 | 1
     2 | 2
     3 | 1 1
     4 | 2 0
     5 | 5
     6 | 1 2
     7 | 1 1 1
     8 | 2 0 0
     9 | 2 1
    10 | 10
    50 | 1 2 2
   100 | 1 2 2 0
  1000 | 1 1 1 1 10 0 0
 10000 | 2 1 1 2 0 2 0 0 0
 12914 | 1 2 2 1 1 2 2
371017 | 5 42 10 2 1

추가 사항 : 출력의 모든 숫자는 (2^k-1)/3또는 형식이어야합니다 2*(2^k-1)/3. 즉, 0 1 2 5 10 21, 42, 85, 170, ...,이다 A000975 OEIS한다.

Pyth, 17 16 바이트

Jakube 덕분에 1 바이트

iR2cJ.BQx1qVJ+dJ

데모

훌륭하고 영리한 솔루션. Pyth 같은 일부 덜 알려진 기능 사용 x<int><list>과 c<str><list>.

iR2cJ.BQx1qVJ+dJ
                    Q = eval(input())
    J.BQ            Store in J the input in binary.
          qV        Vectorize equality function over
            J+dJ    J and J with a leading dummy char, to get the offset right.
                    This calculates whether each element matches its successor.
        x1          Find all of the indexes of 1 (True) in this list.
   cJ                Chop J at those locations.
iR2                  Convert from binary back to base ten and output.

수학, 47 바이트

#+##&~Fold~#&/@#~IntegerDigits~2~Split~Unequal&

언 골프 드 :

FromDigits[#,2]&/@Split[IntegerDigits[#,2],Unequal]&

Split[list,f]사이의 위치에 침입, 여러 목록으로 목록을 분할 a하고 bIFF는 f[a,b]반환하지 않습니다 True.

FromDigits[n,2] => Fold[#+##&,n]alephalpha 의 깔끔한 팁 입니다.

파이썬, 86 바이트

내가 Pyth에서 끔찍하게 능가했기 때문에 파이썬에서 다시 할 수 있습니다.

import re
lambda n:[int(s,2)for s in re.sub("(?<=(.))(?=\\1)"," ",bin(n)[2:]).split()]

여기 사용해보십시오!

설명

입력 번호 n를 이진 문자열로 변환하는 것으로 시작 합니다. bin(n)[2:]처리합니다. bin()문자열을 형식으로 반환 하므로이 문자열의 처음 2자를 버려야 합니다 0b10101.
다음으로 하위 시퀀스의 경계를 식별해야합니다. 이것은 (?<=(.))(?=\1)왼쪽과 오른쪽에 같은 숫자를 갖는 문자열에서 길이가 0 인 위치와 일치 하는 정규 표현식으로 수행 할 수 있습니다 .
모든 하위 시퀀스 목록을 얻는 확실한 방법 re.split()은 특정 정규식에서 문자열을 분할하는 것을 사용 하는 것 입니다. 불행하게도이 함수는 길이가 0 인 일치에는 작동하지 않습니다. 그러나 운 좋게도 re.sub(), 우리는 길이가 0 인 일치 항목을 공백으로 바꾸고 그 후에 문자열을 분할합니다.
그런 다음 각 하위 시퀀스를 10 진수로 다시 구문 분석해야합니다 int(s,2).

젤리, 12 바이트

BI¬-ẋż@BFṣ-Ḅ

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

BI¬-ẋż@BFṣ-Ḅ  Main link. Argument: n

B             Convert n to base 2.
 I            Compute the increments, i.e., the differences of consecutive digits.
  ¬           Apply logical NOT.
   -ẋ         Repeat -1 that many times, for the logical NOT of each difference.
              [0, 0] / [1, 1] ->   0    -> 1 -> [-1]
              [0, 1] / [1, 0] -> 1 / -1 -> 0 -> []
       B      Yield n in base 2.
     ż@       Zip the result to the right with the result to the left.
        F     Flatten the resulting list of pairs.
         ṣ-   Split at occurrences of -1.
           Ḅ  Convert each chunk from base 2 to integer.

배쉬 + GNU 유틸리티, 51

dc -e2o?p|sed -r ':;s/(.)\1/\1 \1/;t'|dc -e2i?f|tac

STDIN에서 가져온 입력.

• dc -e2o?p STDIN에서 입력 정수를 읽고 기본 2 문자열을 출력합니다.
• sed -r ':;s/(.)\1/\1 \1/;t' 동일한 연속 자릿수가있는 곳마다 공백으로 기본 2 문자열을 분할합니다.
• dc -e2i?f분할 바이너리를 한 번에 읽고 스택에 각 부분을 넣은 다음 f전체 dc스택 을 덤프합니다 (출력 번호를 역순으로) ...
• ...로 수정됩니다 tac.

자바 스크립트 (ES6) 58 62 63

1 바이트 저장된 thx @ETHproductions 편집

thx @Neil으로 저장된 4 바이트 편집

x=>x.toString(2).replace(/((.)(?!\2))*./g,x=>'0b'+x-0+' ')

f=x=>x.toString(2).replace(/((.)(?!\2))*./g,x=>'0b'+x-0+' ')

 
console.log=x=>O.textContent+=x+'\n'

;[
[     0,'0'],
[     1,'1'],
[     2,'2'],
[     3,'1 1'],
[     4,'2 0'],
[     5,'5'],
[     6,'1 2'],
[     7,'1 1 1'],
[     8,'2 0 0'],
[     9,'2 1'],
[    10,'10'],
[    50,'1 2 2'],
[   100,'1 2 2 0'],
[  1000,'1 1 1 1 10 0 0'],
[ 10000,'2 1 1 2 0 2 0 0 0'],
[ 12914,'1 2 2 1 1 2 2'],
[371017,'5 42 10 2 1']
].forEach(t=>{
  var i=t[0],k=t[1],r=f(i)
  console.log(i+' -> '+r+(r.trim()==k.trim() ? ' ok':'ko (should be '+k+')'))
})

<pre id=O></pre>

Pyth, 26 바이트

iR2c:.BQ"(?<=(.))(?=\\1)"d

여기 사용해보십시오!

설명

iR2c : .BQ "(? <= (.)) (? = \\ 1)"d # Q = 입력 번호

     .BQ # 입력을 이진수로 변환
    : "(? <= (.)) (? = \\ 1)"d # 하위 시퀀스 사이에 공백을 삽입하십시오
   공백에 c # 분할 문자열
iR2 # 각 하위 시퀀스를 10 진수로 변환

Python의 split () 함수는 길이가 0 인 일치 항목으로 분할되지 않으므로 해당 일치 항목을 공백으로 바꾸고 결과를 분할해야합니다.

Pyth, 22 21 바이트

&Qu?q%G2H&
GH+yGHjQ2Z

온라인으로 사용해보십시오 : 데모

Pyth에서 정말 지루한 작업입니다.

설명:

&Qu?q%G2H&\nGH+yGHjQ2Z   implicit: Q = input number
                  jQ2    convert Q to base 2
  u               jQ2Z   reduce ^: for each digit H update the variable G=0:
   ?q%G2H                   if G%2 == H:
          \nG                  print G
         &   H                 then update G with H
              +yGH           else: update G with 2*G+H
  u                      print the last G also
&Q                       handle Q=0 special: only print 0 once

05AB1E , 18 바이트

암호:

b2FNð«N«Dð-s:}ð¡)C

설명:

b                   # Convert input to binary
 2F          }      # Do the following twice ( with N as range variable)
   Nð«N«            #    N + space + N
        D           #    Duplicate this
         ð-         #    Delete spaces from the duplicate string
           s        #    Swap the top two elements
            :       #    Replace the first string with the second
              ð¡    # Split on spaces
                )   # Wrap into an array
                 C  # Convert all element back to decimal

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

CP-1252 인코딩을 사용합니다 .

MATL , 18 17 바이트

YBTyd~Thhfd1wY{ZB

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

YB      % input number. Convert to binary string
T       % push true value
y       % duplicate binary string and push it at the top of the stack
d~      % true for each value that equals the previous one
T       % push true value
hh      % concatenate: true, indices, true
f       % find indices of true values
d       % consecutive differences: lenghts of alternating sequences
1wY{    % split binary string according to those lengths
ZB      % convert each substring into decimal number

zsh, 67 63 55 바이트

for i in `grep -oP '1?(01)*0?'<<<$[[##2]$1]`;<<<$[2#$i]

이유를 모르겠지만 Bash에서는 작동하지 않습니다.

8 바이트의 Dennis 에게 감사 합니다!

PHP, 171 168 162 160 158 121 120 131 124 118 116 113 112 바이트

function d($i){for(;$d<$l=strlen($b=decbin($i));){$c.=$u=$b[$d];echo$u==$b[++$d]||$d==$l?bindec($c).$c=" ":"";}}

function d($i) {
  for ( ; $d < $l = strlen($b = decbin($i)); ) {
    $c .= $u = $b[$d];
    echo $u == $b[++$d] || $d == $l ? bindec($c) . $c = " "
                                    : "";
  }
}

사용 d(int)하고 꺼져 있다면 출력은 공백으로 구분 된 s echo문자열입니다 int.

편집 :
-3 :$b 정의를 strlen()호출 로 이동했습니다 .
-6 :$c 인스턴스화 제거 .
-2 : 마지막으로 연결 문제가 해결되었습니다.
-2 : 한 줄에 대괄호가 없습니다 for().
-37 : 전체 점검. 함께가는 Array대신 반복의 chunklets Array> - String-> Array호출합니다.
-1 : 부적절한 $c재설정.
+11 : 버그 수정. 최종 청크가 없습니다. 더 이상은 없어.
-7 : 전혀 인스턴스화 할 필요가 $d없습니까? 좋은.
-6 : return -> echo.
-2 : 크 런칭 $c.
-삼:테너 리, 내 첫사랑
-1 : 부적절한 몰래 $u.

볼록 0.2+, 25 바이트

Convex는 CJam과 Golfscript를 기반으로 개발중인 새로운 언어입니다. 인터프리터와 IDE는 여기 에서 찾을 수 있습니다 . 입력은 명령 행 인수에 대한 정수입니다. CP-1252 인코딩을 사용합니다 .

2bs®(?<=(.))(?=\\1)"ö2fbp

설명:

2bs                         Convert to binary string
   ®(?<=(.))(?=\\1)"        Regex literal
                    ö       Split string on regex
                     2fb    Convert each split string into decimal integer
                        p   Print resulting array

자바 8, 127 119 바이트

l->new java.util.ArrayList<Long>(){{for(String s:l.toBinaryString(l).split("(?<=(.))(?=\\1)"))add(l.parseLong(s,2));}};

문자열을 분할하기 위해 더 나은 정규 표현식이있을 수 있습니다. 정규식에 능숙하지는 않지만 실험을 계속할 것입니다.

@FryAmTheEggman 덕분에 -8 바이트

APL (APL) , 21 25 바이트

이제 0도 처리합니다.

{0::0⋄2⊥¨⍵⊂⍨1,2=/⍵}2⊥⍣¯1⊢

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

2⊥⍣¯1⊢ 필요한만큼의 비트를 사용하여 base-2로 변환 (lit-base-base-2 변환)

{… } 다음 익명 기능을 적용하십시오

0:: 오류가 발생하면 :

  0 0을 반환

 ⋄ 이제 시도하십시오 :

  2=/⍵ 인수의 쌍별 동등성 (0의 길이 -0 이진 표현 중 하나가 실패 함)

  1, 앞에 1

  ⍵⊂⍨ 이것을 사용하여 인수를 분할하십시오 (각각의 새로운 섹션 시작)

  2⊥¨ 기본 -2에서 각각 변환

Japt , 7 바이트

¤ò¥ mn2

그것을 테스트

설명

¤ò¥ mn2
           :Implicit input of integer U.
¤          :Convert to binary string.
 ò¥        :Split to an array by checking for equality.
    m      :Map over array.
     n2    :Convert to base-10 integer.

파이썬 3, 115 바이트

def f(s):
 s=bin(s);r=[s[2]]
 for i in s[3:]:
  if i==r[-1][-1]:r+=[i]
  else:r[-1]+=i
 return[int(x,2)for x in r]

설명

def f(s):
 s=bin(s)                   # convert input in binary
 r=[s[2]]                   # initialize the result with the first char after the 'b' in binary string
 for i in s[3:]:            # loop on other element
  if i==r[-1][-1]:          # if the last element of the last string equal the current element 
   r+=[i]                   # we add the current element in a new string
  else:
   r[-1]+=i                 # we add the current element to the last sting
 return[int(x,2)for x in r] # convert binary string in integer 

결과

>>> [print(i,f(i)) for i in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 50, 100, 1000, 10000, 12914, 371017]]
0 [0]
1 [1]
2 [2]
3 [1, 1]
4 [2, 0]
5 [5]
6 [1, 2]
7 [1, 1, 1]
8 [2, 0, 0]
9 [2, 1]
10 [10]
50 [1, 2, 2]
100 [1, 2, 2, 0]
1000 [1, 1, 1, 1, 10, 0, 0]
10000 [2, 1, 1, 2, 0, 2, 0, 0, 0]
12914 [1, 2, 2, 1, 1, 2, 2]
371017 [5, 42, 10, 2, 1]

이전 솔루션 (118 바이트)

def f(s):
 s=bin(s);r=s[2]
 for i in s[3:]:
  if i==r[-1]:r+='a'+i
  else:r+=i
 return[int(x,2)for x in r.split('a')]

하스켈, 147 , 145 바이트

x%[]=[x]
x%(y:z)|or.(zipWith(==)<*>tail)$y:x=x:[]%(y:z)|1<2=(y:x)%z
b x|x<2=[x]|1<2=b(div x 2)++[mod x 2]
map(sum.zipWith((*).(2^))[0..]).([]%).b

map(sum.zipWith((*).(2^))[0..]).([]%).b 목록을 계산하는 명명되지 않은 함수입니다.

덜 골프 :

alternating :: Eq a => [a] -> Bool
alternating = or . (zipWith (==) <*> tail)

-- (%) is the partitioning function
(%) :: Eq a => [a] -> [a] -> [[a]]
x % [] = [x]

x % (y:z) | alternating (y : x) = x : [] % (y:z)
          | otherwise = (y : x) % z

bits :: Integral t => t -> [t]
bits x | x < 2     = [x] 
       | otherwise = bits (div x 2) ++ [mod x 2]

unBits :: Num c => [c] -> c
unBits = sum . zipWith ((*) . (2^)) [0..]

f :: Integer -> [Integer]
f = map unBits . ([]%) . bits

펄, 53 바이트

에 +1 포함 -p

STDIN의 숫자로 실행

perl -p alterbits.pl <<< 371017

alterbits.pl:

$_=sprintf"0b%b",$_;s/(.)\K(?=\1)/ 0b/g;s/\S+/$&/eeg

PowerShell, 103 바이트

[regex]::Matches([convert]::ToString($args[0],2),"(01)+0?|(10)+1?|.").Value|%{[convert]::toint32($_,2)}

정규식에 끔찍하기 때문에 edc65의 답변 과 동일한 표현을 사용하고 있습니다.

이진과의 변환을 위해 긴 .NET 호출과 정규식 일치를 얻기위한 .NET 호출에 의해 절대적으로 파괴됩니다. 그렇지 않으면 매우 간단합니다. 입력을 취하고 $args[0], convert이진으로 S는,로 피드 Matches, 얻어진 소요 .ValueS를 통해 파이프 루프들을 |%{...}그리고 convert그 값으로 다시이야 int. 출력은 파이프 라인에 남겨지고 개행으로 내재적으로 인쇄됩니다.

추가 크레딧-126 바이트 (대부분의 비정규 버전)

$l,$r=[char[]][convert]::ToString($args[0],2);$l+-join($r|%{(" $_",$_)[$l-bxor$_];$l=$_})-split' '|%{[convert]::toint32($_,2)}

우리는 다시 입력 $args[0]과 convert바이너리를 가져옵니다 . 첫 번째 문자는 $l에, 나머지 문자는 에 저장하는 문자 배열로 다시 캐스팅 $r합니다. 그런 다음 이진 xor의 결과에 따라 공백이 앞에 붙은 문자 나 문자 만 선택하여 반복 할 때마다 $r루프를 통해 보낸 다음 |%{...}문자와 동일하게 $l설정 $l합니다. 이렇게하면 같은 문자가 두 번 연속으로있을 경우 그 사이에 공백이 추가됩니다.

루프의 출력은 -join함께 연결되고 첫 번째 문자에 추가 된 $l다음 -split공백 (기술적으로 정규식이지만 계산하지는 않습니다)에 추가됩니다. 그런 다음 정규식 응답 convert과 동일한 루프를 수행하고 정수를 출력합니다.

자바 345 바이트

package com.ji.golf;
import java.util.regex.*;
public class Decompose {
  public static String decompose(long l) {
    String o="";
    String s=Long.toBinaryString(l);
    Matcher m=Pattern.compile("(01)+(0)?|(10)+(1)?|(1)|(0)").matcher(s);
    while(m.find()){String c=s.substring(m.start(),m.end());o+=Integer.parseInt(c, 2)+" ";}
    return o;
  }
}

테스트

package com.ji.golf;
public class DecompseTest {
  public static void main(String[] args) {
    String[] inOut = new String[]{
        "0,0",
        "1,1",
        "2,2",
        "3,1 1",
        "4,2 0",
        "5,5",
        "6,1 2",
        "7,1 1 1",
        "8,2 0 0",
        "9,2 1",
        "10,10",
        "50,1 2 2",
        "100,1 2 2 0",
        "1000,1 1 1 1 10 0 0",
        "10000,2 1 1 2 0 2 0 0 0",
        "12914,1 2 2 1 1 2 2",
        "371017,5 42 10 2 1"
    };
    for (String s : inOut) {
      String[] io = s.split(",");
      String result = Decompose.decompose(Long.parseLong(io[0]));
      System.out.println("in: " + io[0] + ", reusult: [" +  result.trim() + "], validates? " + result.trim().equals(io[1].trim()));
    }
  }
}

산출

in: 0, reusult: [0], validates? true
in: 1, reusult: [1], validates? true
in: 2, reusult: [2], validates? true
in: 3, reusult: [1 1], validates? true
in: 4, reusult: [2 0], validates? true
in: 5, reusult: [5], validates? true
in: 6, reusult: [1 2], validates? true
in: 7, reusult: [1 1 1], validates? true
in: 8, reusult: [2 0 0], validates? true
in: 9, reusult: [2 1], validates? true
in: 10, reusult: [10], validates? true
in: 50, reusult: [1 2 2], validates? true
in: 100, reusult: [1 2 2 0], validates? true
in: 1000, reusult: [1 1 1 1 10 0 0], validates? true
in: 10000, reusult: [2 1 1 2 0 2 0 0 0], validates? true
in: 12914, reusult: [1 2 2 1 1 2 2], validates? true
in: 371017, reusult: [5 42 10 2 1], validates? true

줄리아, 70 57 바이트

n->map(i->parse(Int,i,2),split(bin(n),r"(?<=(.))(?=\1)"))

이것은 정수를 받아들이고 정수 배열을 반환하는 익명 함수입니다. 호출하려면 변수에 지정하십시오.

이 방법은 DenkerAffe의 멋진 Python 답변 과 비슷합니다 . 우리는 nusing 의 이진 표현을 얻고 bin(n)정규식과 일치하는 모든 결과 문자열을 나눕니다 (?<=(.))(?=\1). 실제로는 길이가 0입니다. (?<=(.))은 단일 문자를 찾는 긍정적 인 룩백 (?=\1)이며, 룩 베어에서 일치하는 문자를 찾는 긍정적 인 룩어 헤드입니다. 이것은 이진 표현에서 숫자가 뒤에 오는 장소를 찾습니다. 그냥 parse정수로 각 기본 2 사용에 map짜잔!

C, 137129 바이트

main(){unsigned long a,b=scanf("%lu",&a),c=!!a;while(a>=b*2)b*=2;while(b)b/=2,c=c*(~(a^a/2)&b|!b?!printf("%lu\n",c):2)+!!(a&b);}

입력 및 출력은 표준 스트림에 있습니다.

J , 16 바이트

#:#.;.1~1,2=/\#:

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

설명

#:#.;.1~1,2=/\#:  Input: integer n
              #:  Convert from decimal to list of binary digits
          2  \    For each overlapping sublist of size 2
           =/       Reduce using equals
        1,        Prepend 1
#:                Binary digits
    ;.1~          Partition those binary digits at the 1s in the previous list
  #.                Convert each partition from a list of binary digits to decimal

q / kdb +, 52 바이트

해결책:

{2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}

예 :

q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}0
,0
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}1
,1
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}3
1 1
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}8
2 0 0
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}10000
2 1 1 2 0 2 0 0 0
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}12914
1 2 2 1 1 2 2
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}371017
5 42 10 2 1
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}727429805944311
10 21 2 5 1 1 1 1 1 2 1 2 5 1 85 5 1 1 1 5 1 1

설명:

q 오른쪽에서 왼쪽으로 해석됩니다.

입력을 이진으로 변환하고 선행 0을 잘라 내고 다른 곳에서 인덱스를 찾은 다음 같은 인덱스에서 인덱스를 가져 오려면이 인덱스에 대한 분할 목록을 다시 밑으로 10으로 변환하십시오. 그래도 APL 솔루션에 비해 약간 무겁게 보입니다 ...

{2 sv'cut[0,where not differ a]a:(63^first where a)_a:0b vs x} / ungolfed solution
{                                                            } / lambda function
      cut[                    ]                                / cut a list at indices, cut[indices]list
                                                      0b vs x  / converts to 64bit binary representation
                                                    a:         / save as a
                                                   _           / drop 'n' elements from a
                                 (                )            / evaluate this
                                     first where a             / returns first occurance of true in list a
                                  63^                          / fill result with 63 if null (to handle input of 0)
                               a:                              / save as a, we've stripped off all the left-most 0s
                      differ a                                 / whether or not item in list a is different to previous
                  not                                          / the inversion of this result
            where                                              / these are the points where we have 00 or 11
          0,                                                   / add the first index too!
  2 sv'                                                        / 2 sv converts binary back to base-10, ' for each list

PHP, 147

$b=decbin($argv[1]);$a=[$t=$b[0]];$k=0;for($i=1;$i<strlen($b);$i++){$v=$b[$i];if($v==$t)$k++;$t=$v;$a[$k].=$v;}foreach($a as$c)echo bindec($c).' ';

제한이 없으므로 출력의 마지막에 여분의 공간을 두어야합니다. 짧은 코딩에 대한 통지가 표시됩니다.

언 골프 버전

$n=$argv[1];
$b=decbin($n);
$l=strlen($b);
$t=$b[0];
$a=[0=>$t];$k=0;
for($i=1;$i<$l;$i++){
    $v=$b[$i];
    if($v==$t){
        $k++;
    }
    $t=$v;$a[$k].=$v;    
}
foreach($a as $c){
    echo bindec($c).' ';
}

망막, 60

+`(1+)\1
$1a
a1
1
(?<=(.))(?=\1)
¶
+`1(a*)\b
a$.1$*1;
a

;
1

온라인으로 사용해보십시오! 또는 모든 테스트 사례 (소수점 I / O 포함)에 대해 약간 수정 된 버전을 사용해보십시오 .

불행하게도 길이가 0 인 일치 항목에는 두 개의 "변"이있는 것으로 보이므로 세 번째 단계에서 정규식과 함께 사용할 때 중복이 발생합니다. 그래도 1 바이트 비용입니다.

단항으로 입력을 받고 단항으로 출력합니다. 다른 인 / 아웃 단항 값을 사용하는 것은 확실하지 않지만 4 바이트를 절약 할 수 있습니다.

젤리 , 9 바이트 (비경쟁?)

BI¬0;œṗBḄ

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