Cómo funciona la codificación

Dada una lista de bits:

Mantenga una prima (comenzando con 2)
Tener una lista
Para cada bit en la entrada
- Si es lo mismo que el bit anterior, agregue la prima que está sosteniendo a la lista
- Si es diferente, sostenga el próximo primer y agréguelo a la lista
Devuelve el producto de todos los números en tu lista
Para el primer bit, suponga que el bit anterior fue 0

Nota: estos pasos son solo para fines ilustrativos, no es necesario que los siga.

Ejemplos

Input: 001
hold 2

0:         add 2 to the list
0:         add 2 to the list
1: hold 3, add 3 to the list

list: 2,2,3
Output: 12

Input: 1101
hold 2

1: hold 3, add 3 to the list
1:         add 3 to the list
0: hold 5, add 5 to the list
1: hold 7, add 7 to the list

list: 3,3,5,7
Output: 315

Algunos ejemplos más:

000000000 -> 512
111111111 -> 19683
010101010 -> 223092870
101010101 -> 3234846615
011101101 -> 1891890
000101101010010000 -> 3847834029582062520

Desafío

Escriba un codificador y un decodificador para este método de codificación.

(El decodificador invierte el proceso del codificador).

De entrada y salida

El codificador puede recibir información en cualquier formato razonable
El codificador debe generar un entero o una cadena
El decodificador debe tomar la entrada en el mismo formato que el codificador utiliza
El decodificador debe generar el mismo formato que el codificador toma como entrada

En otras palabras decoder( encoder( input ) ) === input

Notas

El decodificador puede asumir que su entrada es decodificable
Su respuesta sólo tiene que lidiar con números enteros que su lenguaje puede soportar de forma nativa sin necesidad de utilizar ( long, bigInt, etc.), ser razonable, si sólo idioma sostiene enteros hasta 1, tal vez reconsidere publicar una respuesta

Puntuación

Su puntaje es la suma de las longitudes en bytes del codificador y decodificador.

Si necesita importar un módulo, la importación puede contarse solo una vez, siempre que su codificador y decodificador puedan coexistir en el mismo archivo y reutilizarse (como funciones).

Las lagunas predeterminadas están prohibidas.

Este es el código de golf, por lo que gana el puntaje más corto para cada idioma.

— Asone Tuhid
fuente

¿Es obligatorio este último ejemplo, o podemos limitar la salida a hasta 64 bits (2 ^ 63-1 / 9223372036854775808)?

— Kevin Cruijssen

1

@KevinCruijssen No, su respuesta solo tiene que funcionar para enteros que su idioma pueda manejar.

— Asone Tuhid

1

@KevinCruijssen * manejar de forma nativa sin bibliotecas de bigints,

— aclararé

8

05AB1E , 13 bytes

Codificador, 8 bytes

0ì¥ĀηOØP

Pruébalo en línea!

Explicación

0ì          # prepend 0 to input
  ¥         # calculate deltas
   Ā        # truthify each
    η       # calculate prefixes
     O      # sum each
      Ø     # get the prime at that index
       P    # product

Decodificador, 5 bytes

Ò.ØÉJ

Pruébalo en línea!

Explicación

Ò       # get prime factors of input
 .Ø     # get their indices among the primes
   É    # check for oddness
    J   # join

— Emigna
fuente

7

Jalea , 17 bytes

Codificador (10 bytes):

0;IA+\‘ÆNP

Pruébalo en línea!

Decodificador (7 bytes):

ÆEĖŒṙḂ¬

Pruébalo en línea!

¿Cómo?

Codificador:

0;IA+\‘ÆNP - Link: list of integers (1s and 0s)  e.g. [1,1,1,1,0]
0;         - prepend a zero                           [0,1,1,1,1,0]
  I        - incremental differences                  [1,0,0,0,-1]
   A       - absolute values                          [1,0,0,0,1]
    +\     - cumulative reduce with addition          [1,1,1,1,2]
      ‘    - increment each of the results            [2,2,2,2,3]
       ÆN  - get the nth prime for each result        [3,3,3,3,5]
         P - product of the list                      405

Descifrador:

ÆEĖŒṙḂ¬ - Link: integer         e.g. 405
ÆE      - prime exponent array       [0,4,1] (representing 2^0*3^4*5^1)
  Ė     - enumerate                  [[1,0],[2,4],[3,1]]
   Œṙ   - run-length decode          [2,2,2,2,3]
     Ḃ  - bit (mod 2)                [0,0,0,0,1]
      ¬ - logical NOT                [1,1,1,1,0]

— Jonathan Allan
fuente

5

JavaScript (ES6), 130 bytes

E / S: matriz de bits ↔ entero

Codificador, 71 bytes

a=>a.map(p=k=>r*=(g=i=>n%--i?g(i):i<2?n:g(++n))(n+=p^(p=k)),r=1,n=2)&&r

Pruébalo en línea!

Decodificador, 59 bytes

D=(n,k=2,x=b=0)=>k>n?[]:n%k?D(n,k+1,1):[b^=x,...D(n/k,k,0)]

Pruébalo en línea!

— Arnauld
fuente

3

Java 10, 209 bytes

Codificador, 124 bytes

s->{long p=48,P=2,r=1,n,i;for(int c:s.getBytes()){if(p!=(p=c))for(n=0;n<2;)for(n=++P,i=2;i<n;n=n%i++<1?0:n);r*=P;}return r;}

Pruébalo en línea.

Explicación:

s->{                // Method with String parameter and long return-type
  long p=48,        //  Previous character, starting at '0'
       P=2,         //  Current prime, starting at 2
       r=1,         //  Result, starting at 1
       n,i;         //  Temp-integers
  for(int c:s.getBytes()){
                    //  Loop over the digits of the input-String as bytes
    if(p!=(p=c))    //   If the current and previous digits are different
      for(n=0;      //    Reset `n` to 0
          n<2;)     //    And loop as long as `n` is still 0 or 1
        for(n=++P,  //     Increase `P` by 1 first with `++P`, and set `n` to this new `P`
            i=2;i<n;n=n%i++<1?0:n);
                    //     Check of the current `n` is a prime
                    //     If it remains the same it's a prime, if it becomes 0 or 1 not
    r*=P;}          //   Multiply the result by the current prime `P`
  return r;}        //  Return the result

Decodificador, 85 bytes

n->{var r="";for(long P=2,f=0,i=1;++i<=n;)for(;n%i<1;n/=P=i)r+=i!=P?f^=1:f;return r;}

Pruébalo en línea.

Explicación:

n->{                // Method with long parameter and String return-type
  var r="";         //  Result-String, starting empty
  for(long P=2,     //  Current prime, starting at 2
      f=0,          //  Flag integer, starting at 0
      i=1;++i<=n;)  //  Loop `i` in the range [2,`n`]
    for(;n%i<1;     //   Inner loop over the prime factors of `n`
        n/=P=i)     //     After every iteration: divide `n` by `i`,
                    //     and set `P` to `i` at the same time
      r+=i!=P?      //    If `i` and `P` are not the same
          f^=1      //     Append the opposite of the flag `f` (0→1; 1→0)
         :          //    Else:
          f;        //     Append the flag `f`
  return r;}        //  Return the result

— Kevin Cruijssen
fuente

Puede guardar 2 bytes cambiando longa int.

— Asone Tuhid

3

Casco , 18 bytes

Codificador, 11 bytes

Πmo!İp→∫Ẋ≠Θ

Pruébalo en línea!

Decodificador, 7 bytes

mȯ¬%2ṗp

Pruébalo en línea!

Cómo trabajan ellos

Codificador:

Πmo! İp → ∫Ẋ ≠ Θ - Programa completo. Toma la entrada del primer CLA, las salidas a STDOUT.
          Θ - Anteponer un elemento predeterminado (0 en este caso).
        Ẋ ≠ - Mapa sobre pares de elementos adyacentes con ≠ (no es igual). En cáscara
              algunos operadores devuelven otras cosas útiles además de los valores booleanos.
              Aquí, ≠ devuelve la diferencia absoluta entre sus dos argumentos.
       ∫ - Sumas acumulativas.
 mo: asigna la siguiente función a la lista de sumas:
    İp - Produce la lista infinita de primos.
   ! → - E indexar en él con la suma actual incrementada.
Π - Toma el producto.

Descifrador:

mȯ¬%2ṗp – Full program.
      p – Prime factorization.
mȯ      – Map the following function over the list of factors:
     ṗ    – Retrieve the index in  the list of primes.
   %2     – Modulo 2.
  ¬       – Logical NOT.

— Sr. Xcoder
fuente

3

Python 2 , 234 193 174 bytes

Encoder, 116 101 97 bytes:

Utiliza el teorema de Wilson .

i=input()
P=n=x=r=1
while i:
 P*=n*n;n+=1
 if P%n:t=(i+[x]).index(x);i=i[t:];r*=n**t;x^=1
print r

Pruébalo en línea!

Decodificador, 118 92 77 bytes:

i=input()
r=[]
n=x=1
while~-i:
 n+=1;x^=i%n<1
 while i%n<1:r+=x,;i/=n
print r

Pruébalo en línea!

— ovs
fuente

1

J , 34 bytes

¡Muy inspirado por la solución Jelly de Jonathan Allan!

Codificador: 23 bytes

[:*/[:p:[:+/\2|@-~/\0,]

Pruébalo en línea!

                    0,]  NB. prepend 0 to the input
             2  -~/\     NB. find the differences
              |@         NB. and their absolute values 
        [:+/\            NB. running sums
    [:p:                 NB. n-th prime
[:*/                     NB. product

No me gustan esas horquillas [:, debería ser golfable.

Decodificador: 11 bytes

2|[:_1&p:q:

Pruébalo en línea!

        q:    NB. prime factorization
  [:_1&p:      NB. find the number of primes smaller than n
2|             NB. modulo 2

— Galen Ivanov
fuente

1

Jalea , 15 bytes

Codificador, 9 bytes

0;ŒgL€ÆẸH

Pruébalo en línea!

Decodificador, 6 bytes

Æf’ÆCḂ

Pruébalo en línea!

— Dennis
fuente

1

C (gcc) , 180 184 bytes

Se agregaron cuatro bytes para que los formatos de salida coincidan.

102 bytes - Codificador

p,r,i,m;e(char*_){for(m=0,p=1,i=2;*_;m=*_++-48,p*=i)if(*_-48-m)for(i++,r=2;r<i;i%r++||(r=2,i++));i=p;}

Pruébalo en línea!

82 bytes - Decodificador

d(C){for(m=C%2,r=2+m,p=2;C>1;p++)if(C%p<1)p-r&&(m=!m,r=p),putchar(m+48),C/=p,p=1;}

Pruébalo en línea!

— Jonathan Frech
fuente

@AsoneTuhid Lo siento, leí mal.

— Jonathan Frech

@AsoneTuhid Now agregó un decodificador. Esperemos que cumpla ahora.

— Jonathan Frech

@ovs True; gracias por tu comentario

— Jonathan Frech

1

Gol> <> , 29 + 39 = 68 bytes

Codificador, 29 bytes

021IEh{$:}-Q$TP:SP?!t$|1k*3R!

Pruébalo en línea!

Decodificador, 39 bytes

02I:MZ;:2k%:z}Q$TP:SP?!t$|1k,{{-z:N}3R!

Pruébalo en línea!

Cómo funcionan estos

Encoder

021IEh{$:}-Q$TP:SP?!t$|1k*3R!

021                            Setup the stack as [last bit, current prime, current output]
   IEh                         Take input as int; if EOF, print top as number and halt
      {$:}-Q          |        If the next bit is different from the last bit...
            $                    Move the prime to the top
             T      t            Loop indefinitely...
              P:SP?!               Increment; if prime, skip `t` i.e. break
                     $           Move the prime to the correct position
                       1k*     Multiply the prime to the output
                          3R!  Skip 3 next commands (the init part)
                               Loop the entire program until EOF

---

Decoder

02I:MZ;:2k%:z}Q$TP:SP?!t$|1k,{{-z:N}3R!

02I                  Setup the stack as [last bit, current prime, encoded]
   :MZ;              If encoded == 1, halt
       :2k%          Compute encoded modulo prime
           :z}       Store NOT of the last at the bottom of the stack
              Q...|  Same as encoder's next-prime loop
1k,                  Divide encoded by prime (assume it is divisible)
   {{                Pull out the two bits at the bottom
     -z              Compute the next bit
       :N}           Print as number with newline, and move to the bottom
          3R!        Skip 3 init commands
                     Loop the entire program until finished

Sería mejor si pudiera jugar golf en el siguiente ciclo principal ...

— Bubbler
fuente

Codificación de factor primo

Cómo funciona la codificación

Ejemplos

Algunos ejemplos más:

Desafío

De entrada y salida

Notas

Puntuación

05AB1E , 13 bytes

Codificador, 8 bytes

Decodificador, 5 bytes

Jalea , 17 bytes

Codificador (10 bytes):

Decodificador (7 bytes):

¿Cómo?

JavaScript (ES6), 130 bytes

Codificador, 71 bytes

Decodificador, 59 bytes

Java 10, 209 bytes

Codificador, 124 bytes

Decodificador, 85 bytes

Casco , 18 bytes

Codificador, 11 bytes

Decodificador, 7 bytes

Cómo trabajan ellos

Python 2 , 234 193 174 bytes

Encoder, 116 101 97 bytes:

Decodificador, 118 92 77 bytes:

J , 34 bytes

Codificador: 23 bytes

Decodificador: 11 bytes

Jalea , 15 bytes

Codificador, 9 bytes

Decodificador, 6 bytes

C (gcc) , 180 184 bytes

102 bytes - Codificador

82 bytes - Decodificador

Gol> <> , 29 + 39 = 68 bytes

Codificador, 29 bytes

Decodificador, 39 bytes

Cómo funcionan estos