"Придатні номери"

У Сем є "блискуча" ідея для стиснення! Ви можете допомогти?

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

Ruby, 35 31 байт

-2 байти завдяки @Doorknob

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

Дивіться це на repl.it: https://repl.it/CnnQ/2

Желе , 13 7 байт

6 байт дякує Згарбу за його алгоритм .

BŒgµL * x @ Ḣµ € FḄ
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 байт

Гольф

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.

Діалог APL , 19 байт

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

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

Ця функція справді є "на вершині" двох функцій, перша функція:

2∘⊥⍣¯1зворотний з бінарні в десяткове цілому конверсії, тобто БІНАР від десяткового цілого перетворення
 два 2 пов'язано ∘ з -По-десятковому ⊥
 повторити операцію ⍣ одне негативного час ¯1(тобто один раз, але перевернуте)

У другій функції вищевказаний бінарний результат представлений ⍵:

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

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

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