"Adatta numeri"

Sam ha un'idea "geniale" per la compressione! Puoi aiutare?

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

Ora sostituisci qualsiasi gruppo di uno o più zeri con un singolo zero. Questo perché il numero è diventato più snello. La tua stringa binaria ora avrà questo aspetto.

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

Ora converti la stringa binaria in una rappresentazione di base 10 e la emetti in qualsiasi formato accettabile. Ecco i tuoi casi di test. Il primo numero intero rappresenta un input e l'ultimo numero intero rappresenta un output. Nota che alcuni numeri non cambiano e quindi possono essere chiamati "adatti"

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 byte

b00¬:C

Spiegazione

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

Provalo online

Salvato 2 byte grazie ad Adnan

Utilità Bash + GNU, 27

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

Ingresso letto da STDIN.

JavaScript (ES6), 41 byte

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

Meduse , 20 byte

p
d
# S
,1
*
\dbi
 2

Provalo online!

Spiegazione

• i è inserito.
• b lo converte in binario (elenco di cifre)
• \dcon argomenti 2e l'elenco di cifre si applica d(cifre binarie al numero) per ogni sottostringa lunghezza 2 dell'elenco di cifre.
• * prende il segno dei risultati: 00 va a 0, tutto il resto a 1.
• ,1 aggiunge un 1 alla fine, quindi l'ultima cifra non viene persa.
• # Sseleziona tra biquelle cifre che hanno un 1 nell'elenco sopra calcolato: quelle che non sono le metà sinistra di 00.
• dconverte nuovamente in numero e pstampa il risultato.

Python 2, 36 byte

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

Un'implementazione diretta ricorsiva senza built-in di conversione di base o operazioni su stringa. Meno golf:

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

Quando nè un multiplo di 4, termina in due 0 in binario, quindi ne tagliamo uno dividendo il pavimento per 2. Altrimenti, ci dividiamo nin (n%2) + 2*(n/2), lasciamo solo l'ultima cifra binaria n%2e ricominciamo sulle altre cifre n/2.

Bash (sed + bc), 60 55 43 byte

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

modificare:

1. modificato sed -E 's/0+in sed 's/00*e modificato echo e pipe utilizzati per passare il valore a bc <<<.
2. Suggerimento brillante di @Digital Trauma!

esempio:

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

Perl 6 ,  31  27 byte

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

Spiegazione:

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

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

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

Esempio:

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 byte

BFFOZtXB

Questa versione funziona solo in MATLAB poiché strrepin MATLAB può gestire input logici. Ecco una versione che funzionerà in Octave (9 byte) (e quindi l'interprete online) che lancia esplicitamente gli input logici da digitare double.

Provalo online

Spiegazione

    % 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 byte.

Risparmiato 4 byte grazie a Sp3000.

Soluzione piuttosto semplice.

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

Javascript (ES6), 40 byte

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

In realtà, 14 byte (non concorrenti)

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

Provalo online!

Questa presentazione non è competitiva perché una correzione è Æstata fatta dopo che questa sfida è stata pubblicata.

Spiegazione:

├`'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

Rubino, 35 31 byte

-2 byte grazie a @Doorknob

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

Guardalo su repl.it: https://repl.it/CnnQ/2

Gelatina , 13 7 byte

6 byte grazie a Zgarb per il suo algoritmo .

BŒgμL * x @ Ḣμ € Fb
BŒgḄBFḄ

Provalo online!

PHP, 53 51 byte

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

Accetta un argomento dalla console.

Grazie a:

@manatwork sostituisce "0" con 0

Perl, 38 + 1 ( -p) = 39 byte

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

Ha bisogno di -pflag per funzionare (ho aggiunto -lflag per renderlo più leggibile, ma non è necessario altrimenti):

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

Nota molto da dire sul codice: converte il numero in binario ( sprintf"%b"), quindi sostituisce i blocchi di zeri di un solo zero e converte il risultato in decimale ( oct"0b".).

C #, 112 91 byte

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

-8 byte grazie a TuukkaX

Java, 75

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

Programma di test:

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 byte

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

PowerShell v2 +, 69 byte

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

( richiesta di funzionalità Un modo più breve per convertire da / in binario in PowerShell )

Accetta input $args[0], utilizza .NET incorporato [convert]::ToString(int,base)per convertire l'intero di input in una stringa di base binaria. Questo è filtrato attraverso il -replaceper eliminare qualsiasi esecuzione di uno o più zeri a solo 0. La stringa risultante viene rimandata indietro nell'altra direzione [convert]::ToInt32(string,base)per trasformare il binario in un numero intero. Quel numero intero viene lasciato sulla pipeline e l'output è implicito.

Casi test

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

Implementazione di riferimento in SILOS "solo" 417 byte

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

Ecco l'implementazione di riferimento completamente non modificata. Come funzione bonus fornisce i passaggi necessari per ottenere una risposta.

/**
*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

Su richiesta, la traduzione è stata cancellata. Sentiti libero di visualizzare la cronologia delle modifiche per recuperarla, altrimenti vai a questo repository per un interprete.

Uscita campione per 65000

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

Pyth, 12

i:.BQ"0+"\02

In linea.

  .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

Retina , 30 byte

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

Provalo online!

E qui ho pensato che Retina sarebbe stata tra le prime risposte ...

Java, 152 143 138 byte

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 byte in meno grazie a @RohanJhunjhunwala. Preferisco tenerlo come un programma pienamente funzionante con main e simili. Tuttavia, ovviamente può essere giocato a golf più altrimenti.
• 5 byte in meno grazie ai suggerimenti di @ LeakyNun.

Dyalog APL , 19 byte

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

ProvaAPL online!

Questa funzione è davvero una "cima" di due funzioni, la prima funzione è:

2∘⊥⍣¯1l' inversa di binary- di conversione -decimal, cioè binary- da -decimal conversione
 due 2 è destinata ∘ a -per decimale ⊥
  ripetere l'operazione ⍣ una volta in negativo¯1 (cioè una volta, ma invertito)

Nella seconda funzione, il risultato binario di cui sopra è rappresentato da ⍵:

{2⊥⍵/⍨~0 0⍷⍵}
 0 0⍷⍵Booleano per dove {0, 0} inizia in ⍵
 ~Negazione booleana, quindi ora abbiamo ᴛʀᴜᴇ ovunque, tranne che per gli zeri non primi nelle corse zero
 ⍵/⍨ utilizziamo quello per filtrare ⍵, quindi questo rimuove i nostri zeri indesiderati
 2⊥convertiti da binario a decimale

TSQL, 143 byte

Non usare build in per convertire da e in binario.

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

Violino

CJam, 16 anni

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

Provalo online

È piuttosto lungo a causa della mancanza di regex.

Spiegazione:

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 byte

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

Programma di test

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 byte

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

Provalo online!

Spiegazione

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

Rubino, 37 35 byte

Risparmio di due byte grazie a manatwork.

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

L'approccio ingenuo. (:

C, 37 byte

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