"맞춤 번호"

샘은 압축에 대한 "화려한"아이디어를 가지고 있습니다! 도울 수 있니?

1-> 1
9-> 1001
15-> 1111
13-> 1101
16-> 10000
17-> 10001
65535-> 111111111111111

이제 하나 이상의 0으로 구성된 그룹을 하나의 0으로 바꿉니다. 숫자가 더 적어 졌기 때문입니다. 바이너리 문자열은 이제 다음과 같습니다.

1-> 1-> 1
9-> 1001-> 101
15-> 1111-> 1111
13-> 1101-> 1101
16-> 10000-> 10
17-> 10001-> 101
65535-> 111111111111111-> 111111111111111

이제 이진 문자열을 다시 기본 10 표현으로 변환하고 허용되는 형식으로 출력합니다. 테스트 사례는 다음과 같습니다. 첫 번째 정수는 입력을 나타내고 마지막 정수는 출력을 나타냅니다. 일부 숫자는 변경되지 않으므로 "적합"이라고 할 수 있습니다.

1-> 1-> 1-> 1
9-> 1001-> 101-> 5
15-> 1111-> 1111-> 15
13-> 1101-> 1101-> 13
16-> 10000-> 10-> 2
17-> 10001-> 101-> 5
65535-> 1111111111111111-> 1111111111111111-> 65535
65000-> 1111110111101000-> 11111101111010-> 16250

05AB1E , 8 6 바이트

b00¬:C

설명

b        # convert input to binary
 00¬:    # replace 00 with 0 while possible
     C   # convert to int

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

Adnan 덕분에 2 바이트 절약

배쉬 + GNU 유틸리티, 27

dc -e2o?p|tr -s 0|dc -e2i?p

STDIN에서 입력을 읽습니다.

자바 스크립트 (ES6), 41 바이트

n=>+`0b${n.toString(2).replace(/0+/g,0)}`

해파리 , 20 바이트

p
d
# S
,1
*
\dbi
 2

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

설명

• i 입력됩니다.
• b 이진 (숫자 목록)으로 변환
• \d인수 2를 사용하면 숫자 목록은 숫자 목록의 d모든 길이 2 하위 문자열에 이진 숫자를 적용 합니다.
• * 결과의 부호를 취합니다 .00은 0에, 다른 모든 것은 1에갑니다.
• ,1 1을 끝까지 태킹하므로 마지막 숫자가 손실되지 않습니다.
• # Sbi위에서 계산 된 목록에서 1 을 가진 숫자 (00의 왼쪽 절반이 아닌 숫자)를 선택합니다 .
• d다시 숫자로 변환 p하고 결과를 인쇄합니다.

파이썬 2, 36 바이트

f=lambda n:n and f(n/2)<<(n%4>0)|n%2

기본 변환 기본 제공 또는 문자열 조작이없는 직접 재귀 구현 덜 골프 :

f=lambda n:n and[f(n/2),n%2+2*f(n/2)][n%4>0]

때 n4의 배수 인 우리가 바닥 나누어 그렇지 않으면 2로하여 하나를 잘라 그래서, 우리가 분할 이진 두 공의에 끝 n으로 (n%2) + 2*(n/2)마지막 이진수두고, n%2다른 자리에 혼자와 같이 Recurse을 n/2.

배쉬 (sed + bc), 60 55 43 바이트

echo $[2#`bc<<<obase=2\;$1|sed s/00\*/0/g`]

편집하다:

1. 변경 sed -E 's/0+을 sed 's/00*변경할 에코 및 파이프와 BC로 값을 전달하는 데 사용 <<<.
2. @Digital Trauma의 훌륭한 제안!

예:

$ bash script.sh 65000
16250
$ bash script.sh 15
15
$ bash script.sh 9
5

펄 6 ,  31  27 바이트

{:2(.base(2).subst(:g,/0+/,0))}
{:2(.base(2)~~{S:g/0+/0/})}

설명:

-> $_ {
  # convert from base 2
  :2(

    # convert to base 2
    $_.base(2)

    # substitute
    .subst(
      :global,
      / 0+ /,  # all substrings made of 0s
      '0'      # with one 0
    )
  )
}

예:

my &fit-compress = {:2(.base(2)~~{S:g/0+/0/})}
say fit-compress 1;     # 1
say fit-compress 9;     # 5
say fit-compress 15;    # 15
say fit-compress 13;    # 13
say fit-compress 16;    # 2
say fit-compress 17;    # 5
say fit-compress 65535; # 65535
say fit-compress 65000; # 16250

# number created with ｢:2( [~] <0 1>.roll: 256 )｣
say fit-compress 80794946326210692074631955353531749442835289622757526957697718534769445507500
# 4240335298301026395935723255481812004519990428936918

MATL, 11 9 8 바이트

BFFOZtXB

strrepMATLAB에서는 논리 입력을 처리 할 수 있으므로이 버전은 MATLAB에서만 작동합니다 . 다음은 옥타브 (9 바이트) (및 온라인 인터프리터)에서 작동하여 논리 입력을 type으로 명시 적으로 캐스팅하는 버전입니다 double.

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

설명

    % Implicitly grab input
B   % Convert decimal to binary
FF  % Create the array [0 0]
O   % Number literal
Zt  % Replaces all [0 0] with [0] (will replace any number of 0's with 0)
XB  % Convert binary to decimal
    % Implicitly display

파이썬 3, 55 , 50 바이트.

Sp3000 덕분에 4 바이트가 절약되었습니다.

매우 간단한 솔루션입니다.

import re
f=lambda x:eval(re.sub('0+','0',bin(x)))

자바 스크립트 (ES6), 40 바이트

n=>'0b'+n.toString(2).replace(/0+/g,0)-0

실제로 14 바이트 (비경쟁)

├`'0;;+(Æ`Y2@¿

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

이 Æ챌린지가 게시 된 후에 대한 버그 수정 이 이루어 졌으므로이 제출은 경쟁이 아닙니다 .

설명:

├`'0;;+(Æ`Y2@¿
├               bin(input) (automatically discards leading zeroes)
 `'0;;+(Æ`Y     call this function until the output stops changing:
  '0;;+           push "0", "00"
       (Æ         replace "00" with "0" in binary string
           2@¿  convert from binary to decimal

루비, 35 31 바이트

@Doorknob 덕분에 -2 바이트

->n{eval ("0b%b"%n).squeeze ?0}

repl.it에서 참조하십시오 : https://repl.it/CnnQ/2

젤리 , 13 7 바이트

알고리즘에 대한 Zgarb 덕분에 6 바이트 .

BŒgµL * x @ Ḣµ € FḄ
BŒgḄBFḄ

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

PHP, 53 51 바이트

<?=bindec(preg_replace("/0+/",0,decbin($argv[1])));

콘솔에서 인수를받습니다.

덕분에 :

@manatwork는 "0"을 0으로 바꿉니다.

펄, 38 + 1 ( -p) = 39 바이트

$_=oct"0b".sprintf("%b",$_)=~s/0+/0/gr

-p실행할 플래그가 필요 합니다 ( -l더 읽기 쉽게하기 위해 플래그를 추가 했지만 달리 필요하지는 않습니다).

perl -plE '$_=oct"0b".sprintf("%b",$_)=~s/0+/0/gr' <<< "1
9
15
13
16
17
65535
65000"

코드에 대해 언급 할 점은 숫자를 이진수 ( sprintf"%b") 로 변환 한 다음 0 블록을 0으로 바꾸고 결과를 10 진수 ( oct"0b".) 로 변환하는 것 입니다.

C #, 112 91 바이트

int x(int x)=>Convert.ToInt32(Rege‌​x.Replace(Convert.ToS‌​tring(x,2),"0+","0"),2);

TuukkaX 덕분에 -8 바이트

자바, 75

int f(Integer x){return x.valueOf(x.toString(x,2).replaceAll("0+","0"),2);}

테스트 프로그램 :

public class Fit {
    int f(Integer x){return x.valueOf(x.toString(x,2).replaceAll("0+","0"),2);}

    public static void main(final String... args) {
        final Fit x = new Fit();
        System.out.println(x.f(65000));
    }
}

PARI / GP , 54 43 바이트

n->fold((a,b)->a+if(b,a+1,a%2,a),binary(n))

PowerShell v2 +, 69 바이트

[convert]::ToInt32(([convert]::ToString($args[0],2)-replace'0+',0),2)

( 기능 요청 PowerShell에서 이진으로 변환하거나 변환하는 더 짧은 방법 )

input을 가져오고 $args[0].NET 내장 기능을 사용하여 [convert]::ToString(int,base)입력 정수를 이진 기본 문자열로 변환합니다. -replace1에서 0 이상의 실행을 제거하기 위해 를 통해 필터링됩니다 0. 결과 문자열은 [convert]::ToInt32(string,base)이진을 다시 정수로 바꾸기 위해 다른 방향을 통해 다시 전송됩니다 . 이 정수는 파이프 라인에 남아 있고 출력은 암시 적입니다.

테스트 사례

PS C:\Tools\Scripts\golfing> 1,9,15,13,16,17,65535,65000|%{"$_ -> " +(.\output-fit-number.ps1 $_)}
1 -> 1
9 -> 5
15 -> 15
13 -> 13
16 -> 2
17 -> 5
65535 -> 65535
65000 -> 16250

SILOS " 참조 "417 바이트의 참조 구현

골프

readIO :
i + 1
I = i
z = 1 
n = 32
b = n
z = 1
n = b
lbla
n - 1
GOSUB p
j = i
j - p
if j b
if z c
z = 1
GOTO e
lblc
b - 1
if n a
GOTO f
lblb
z = 0
A = a
A + 1000
set A 1
i - p
lble
a + 1
if n a
lblf
q = 1000
e = q
e + b
i = 0
lbl>
d = q
d - e
if d ?
n = b
n - i
GOSUB p
g = get q
g * p
o + g
i + 1
q + 1
GOTO >
lbl?
o / 2
printInt o
GOTO z
funcp
p = 1
Z = n
lblQ
if Z C
GOTO D
lblC
Z - 1
p * 2
GOTO Q
lblD
return
lblz

다음은 완전히 구현되지 않은 참조 구현입니다. 보너스 기능으로 답을 얻는 데 필요한 단계를 출력합니다.

/**
*Reference Implementation in the high quality S.I.L.O.S language.
*/
readIO Enter a number to "compress"
//some declarations
i + 1
I = i
z = 1 
//the above is a flag which shows whether or not a zero was last outputted
n = 32
b = n
//maximum number of input bits
printLine Original Binary



lblbinLoop
n - 1
GOSUB pow
j = I
j - p
if j printOne
if z ENDLOOP
print 0
GOTO ENDLOOP
lblprintOne
z = 0
print 1
I - p
lblENDLOOP
if n binLoop




printLine  
printLine Binary "Compressed"


z = 1
n = b


lbltopA
n - 1
GOSUB pow
j = i
j - p
if j printAOne
if z DontPrint
z = 1
print 0
GOTO ENDLOOPA
lblDontPrint
b - 1
if n topA
GOTO endOfBin
lblprintAOne
z = 0
print 1
A = a
A + 1000
set A 1
i - p
lblENDLOOPA
a + 1
if n topA

lblendOfBin

printLine  
printLine -----------
printLine Base 10 Output
print Out Bits:
printInt b

q = 1000
e = q
e + b
i = 0
lblOutputDec
d = q
d - e
if d DONE
n = b
n - i
GOSUB pow
g = get q
g * p
o + g
i + 1
q + 1
GOTO OutputDec
lblDONE
printLine
printLine ---------
o / 2
printInt o

GOTO funcs
//function declarations must be wrapped in gotoes to avoid the interpreter from complaining (breaking)

/**
*This will store the nth power of two in the "p" variable
*/
funcpow
p = 1
Z = n
lbltop
if Z continue
GOTO end
lblcontinue
Z - 1
p * 2
GOTO top
lblend
return

lblfuncs

요청에 따라 트랜스 필 레이션이 삭제되었습니다. 편집 히스토리를보고 복구하려면 이 레포지토리 로 이동하십시오 .

65000의 샘플 출력

Enter a number to "compress"
65000
Original Binary
1111110111101000 
Binary "Compressed"
11111101111010 
-----------
Base 10 Output
Out Bits:14
---------
16250

피스, 12

i:.BQ"0+"\02

온라인.

  .BQ            # Convert input from base 10 to base 2
 :   "0+"\0      # Replace multiple zeroes with single zero
i          2     # Convert back from base 2 to base 10

망막 , 30 바이트

.+
$*1;
+`(1+)\1
$1;
1;
1
;+
0

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

그리고 여기에 Retina가 첫 번째 답변 중 하나라고 생각했습니다 ...

자바 152 143 138 바이트

interface C{static void main(String[]b){Integer i=0;System.out.print(i.parseInt(i.toString(i.parseInt(b[0]),2).replaceAll("0+","0"),2));}}

• @RohanJhunjhunwala 덕분에 9 바이트가 줄었습니다. 나는 main 등으로 완벽하게 작동하는 프로그램으로 유지하는 것을 선호합니다. 그러나 물론 다른 방법으로 골프를 칠 수도 있습니다.
• @LeakyNun의 제안 덕분에 5 바이트가 줄었습니다.

Dyalog APL , 19 바이트

{2⊥⍵/⍨~0 0⍷⍵}2∘⊥⍣¯1

TryAPL 온라인!

이 기능은 실제로 두 기능 중 "정상"이며 첫 번째 기능은 다음과 같습니다.

2∘⊥⍣¯1역 binary-의 행 -decimal 변환, 즉 binary- 에서 -decimal 변환
 두 2 바인딩 ∘ 에 -to-진수 ⊥
 반복 동작 ⍣ 음의 하나의 시간 ¯1(즉, 한번하지만 반전)

두 번째 함수에서 위의 이진 결과는 다음과 같이 표시됩니다 ⍵.

{2⊥⍵/⍨~0 0⍷⍵}
 0 0⍷⍵{0, 0}이 ⍵
 ~Boolean negation으로 시작하는 곳에 대한 Boolean, 이제 우리는 모든 곳에서 ᴛʀᴜᴇ를 갖지만 제로 실행에서 첫 번째 0이 아닌 경우
 ⍵/⍨filter를 필터링하는 데 사용하므로 원치 않는 0을
 2⊥2 진에서 10으로 변환

TSQL, 143 바이트

빌드 인을 사용하여 이진으로 변환하지 않습니다.

골프 :

DECLARE @i INT=65000

,@ CHAR(99)=''WHILE @i>0SELECT @=REPLACE(LEFT(@i%2,1)+@,'00',0),@i/=2WHILE @>''SELECT @i+=LEFT(@,1)*POWER(2,LEN(@)-1),@=STUFF(@,1,1,'')PRINT @i

언 골프 드 :

DECLARE @i INT=65000

,@ CHAR(99)=''
WHILE @i>0
  SELECT @=REPLACE(LEFT(@i%2,1)+@,'00',0),@i/=2

WHILE @>''
  SELECT @i+=LEFT(@,1)*POWER(2,LEN(@)-1),@=STUFF(@,1,1,'')

PRINT @i

깡깡이

CJam, 16

q~2b1+0a%0a*);2b

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

정규식이 없기 때문에 꽤 길다.

설명:

q~     read and evaluate the input number
2b     convert to base 2 (array of 1s and 0s)
1+     append a 1 to deal with trailing zeros
0a%    split by [0], dropping empty pieces; only chunks of 1s are left
0a*    join by [0]
);     discard the 1 we appended before
2b     convert back from base 2

자바, 64 바이트

i->{return i.parseInt(i.toString(i,2).replaceAll("0+","0"),2);};

테스트 프로그램

public static void main(String[] args) {
    Function<Integer, Integer> function = i -> {
        return i.parseInt(i.toString(i, 2).replaceAll("0+", "0"), 2);
    };

    System.out.println(function.apply(1)); // 1
    System.out.println(function.apply(9)); // 5
    System.out.println(function.apply(15)); // 15
    System.out.println(function.apply(13)); // 13
    System.out.println(function.apply(16)); // 2
    System.out.println(function.apply(17)); // 5
    System.out.println(function.apply(65535)); // 65535
}

CJam , 23 바이트

ri2be`{_:g:>{:g}&}%e~2b

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

설명

ri          e# Read input as an integer
2b          e# Convert to binary
e`          e# Run-length encoding. Gives a nested (2D) array with run-lengths 
            e# and binary digits
{           e# This block is mapped over the outer array, i.e. is applied to
            e# each inner array
   _        e#   Duplicate the inner array
  :g        e#   Signum of each element of inner array
  :>        e#   This gives true if second element (digit) is false and first
            e#   element (run-length) is not zero. If so, we need to set that
            e#   run-length to 1
  {:g}&     e#   If that's the case, apply signum to original copy of inner
            e#   array, to make run-length 1
}%          e# End block which is mapped over the outer array
e~          e# Run-length decoding
2b          e# Convert from binary. Implicitly display

루비, 37 35 바이트

manatwork 덕분에 2 바이트를 절약했습니다.

->a{a.to_s(2).gsub(/0+/,?0).to_i 2}

순진한 접근. (:

C, 37 바이트

f(x){return x?f(x/2)<<!!(x%4)|x&1:0;}