"Подходящие номера"

У Сэма есть «блестящая» идея по сжатию! Вы можете помочь?

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

Теперь замените любую группу из одного или нескольких нулей одним нулем. Это потому, что число стало меньше. Ваша двоичная строка теперь будет выглядеть следующим образом.

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

Попробуйте онлайн

Сохранено 2 байта благодаря Аднану

Утилиты Bash + GNU, 27

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

Ввод читать из STDIN.

JavaScript (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 в конец, поэтому последняя цифра не теряется.
• # Sвыбирает из biтех цифр, которые имеют 1 в списке, вычисленном выше: те, которые не являются левой половиной 00.
• dпреобразует обратно в число и pпечатает результат.

Python 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]

Когда nзначение кратно 4, оно заканчивается двумя двоичными числами 0, поэтому мы сокращаем одно делением на пол на 2. В противном случае мы разбиваемся nна части (n%2) + 2*(n/2), оставляем последнюю двоичную цифру в n%2покое и рекурсивно определяем другие цифры n/2.

Bash (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

Perl 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

Эта версия работает только в MATLAB, поскольку strrepв MATLAB может обрабатывать логические входы. Вот версия, которая будет работать в Octave (9 байт) (и, следовательно, онлайн-интерпретатор), которая явно вводит логические входные данные для ввода 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

Python 3, 55 , 50 байтов.

Сохранено 4 байта благодаря Sp3000.

Довольно простое решение.

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

Javascript (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 байт

-2 байта благодаря @ Doorknob

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

Смотрите его на repl.it: https://repl.it/CnnQ/2

Желе , 13 7 байт

6 байтов спасибо Згарбу за его алгоритм .

BŒgμL * х @ Ḣμ € Ф.Б.
BŒgḄBFḄ

Попробуйте онлайн!

PHP, 53 51 байт

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

Принимает аргумент из консоли.

Благодаря:

@manatwork замените "0" на 0

Perl, 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"), затем заменяет блоки нулей на один ноль и преобразует результат в десятичную ( oct"0b".).

C #, 112 91 байт

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

-8 байт благодаря TuukkaX

Ява, 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 )

Принимает ввод $args[0], использует встроенный .NET [convert]::ToString(int,base)для преобразования входного целого числа в двоичную базовую строку. Это фильтрует через, -replaceчтобы убрать любые прогоны из одного или нескольких нулей, чтобы просто 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 байт

Golfed

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

Попробуйте онлайн!

И тут я подумала, что Ретина будет среди первых ответов ...

Java, 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));}}

• На 9 байт меньше благодаря @RohanJhunjhunwala. Я предпочитаю сохранить его как полностью функционирующую программу с основным и тому подобным. Тем не менее, конечно, это может быть в гольф в противном случае.
• На 5 байтов меньше благодаря предложениям @ LeakyNun.

Дьялог АПЛ , 19 байт

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

Попробуй APL онлайн!

Эта функция действительно «поверх» двух функций, первая функция:

2∘⊥⍣¯1обратный из бинарны в десятичное целом конверсии, т.е. бинарен от десятичного целого преобразования
 два 2 связанно ∘ с -в-десятичном ⊥
 повторить операцию ⍣ одно отрицательного время ¯1(т.е. один раз, но перевернутое)

Во второй функции бинарный результат выше представлен ⍵:

{2⊥⍵/⍨~0 0⍷⍵}
 0 0⍷⍵Булево для где {0, 0} начинается в ⍵
 ~Булево отрицание, так что теперь мы имеем ᴛʀᴜᴇ везде, но при непервых нулях в нулевых сериях
 ⍵/⍨используем это для фильтрации ⍵, так что это удаляет наши нежелательные нули
 2⊥преобразования двоичного в десятичное

TSQL, 143 байта

Не использовать встроенные модули для преобразования из и в двоичный файл.

Golfed:

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

Ungolfed:

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

Java, 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 байт

Сохранено два байта благодаря ручной работе.

->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;}