Wie funktioniert die Kodierung?

Eine Liste von Bits gegeben:

Halte eine Primzahl (beginnend mit 2)
Hab eine Liste
Für jedes Bit in der Eingabe
- Wenn es dasselbe wie das vorherige Bit ist, fügen Sie der Liste die Primzahl hinzu, die Sie halten
- Wenn es anders ist, halte die nächste Primzahl und füge sie der Liste hinzu
Geben Sie das Produkt aller Nummern in Ihrer Liste zurück
Für das erste Bit wird angenommen, dass das vorherige Bit war 0

Hinweis: Diese Schritte dienen nur zu Illustrationszwecken. Sie müssen sie nicht befolgen.

Beispiele

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

Einige weitere Beispiele:

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

Herausforderung

Schreiben Sie einen Codierer und einen Decodierer für diese Codierungsmethode.

(Der Decoder kehrt den Vorgang des Encoders um).

Input-Output

Der Encoder kann Eingaben in jedem vernünftigen Format vornehmen
Der Encoder muss entweder eine Ganzzahl oder einen String ausgeben
Der Decoder muss Eingaben in demselben Format vornehmen, das der Encoder ausgibt
Der Decoder muss dasselbe Format ausgeben, das der Encoder als Eingabe verwendet

Mit anderen Worten decoder( encoder( input ) ) === input

Anmerkungen

Der Decoder kann annehmen, dass sein Eingang decodierbar ist
Ihre Antwort muss sich nur auf Ganzzahlen beziehen , die Ihre Sprache von Haus aus unterstützen kann, ohne ( long, bigIntusw.) zu verwenden. Wenn Ihre Sprache nur Ints bis 1 unterstützt, überdenken Sie möglicherweise das Posten einer Antwort

Wertung

Ihre Punktzahl ist die Summe der Längen in Bytes des Codierers und Decodierers.

Wenn Sie ein Modul importieren müssen, kann der Import nur einmal gezählt werden, vorausgesetzt, Ihr Encoder und Decoder können in derselben Datei koexistieren und wiederverwendet werden (ähnliche Funktionen).

Standardlücken sind verboten.

Dies ist Codegolf, daher gewinnt die kürzeste Punktzahl für jede Sprache.

— Asone Tuhid
quelle

Ist das letzte Beispiel obligatorisch oder können wir die Ausgabe auf bis zu 64 Bit beschränken (2 ^ 63-1 / 9223372036854775808)?

— Kevin Cruijssen

1

@KevinCruijssen Nein, Ihre Antwort muss nur für Ganzzahlen funktionieren, die Ihre Sprache verarbeiten kann.

— Asone Tuhid

1

@ KevinCruijssen * behandeln nativ ohne Bibliotheken von Bigints, ich werde klären

— Asone Tuhid

8

05AB1E , 13 Bytes

Encoder, 8 Bytes

0ì¥ĀηOØP

Probieren Sie es online!

Erläuterung

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

Decoder, 5 Bytes

Ò.ØÉJ

Probieren Sie es online!

Erläuterung

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

— Emigna
quelle

7

Gelee , 17 Bytes

Encoder (10 Bytes):

0;IA+\‘ÆNP

Probieren Sie es online!

Decoder (7 Bytes):

ÆEĖŒṙḂ¬

Probieren Sie es online!

Wie?

Encoder:

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

Decoder:

Æ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
quelle

5

JavaScript (ES6), 130 Byte

I / O: Array von Bits ↔ Integer

Encoder, 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

Probieren Sie es online!

Decoder, 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)]

Probieren Sie es online!

— Arnauld
quelle

3

Java 10, 209 Bytes

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

Probieren Sie es online aus.

Erläuterung:

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

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

Probieren Sie es online aus.

Erläuterung:

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
quelle

Sie können durch Ändern 2 Bytes speichern longzu int.

— Asone Tuhid

3

Schale , 18 Bytes

Encoder, 11 Bytes

Πmo!İp→∫Ẋ≠Θ

Probieren Sie es online!

Decoder, 7 Bytes

mȯ¬%2ṗp

Probieren Sie es online!

Wie sie arbeiten

Encoder:

Πmo! İp → ∫Ẋ ≠ Θ - Volles Programm. Übernimmt die Eingabe von der ersten CLA und gibt sie an STDOUT aus.
          Θ - Ein Standardelement voranstellen (in diesem Fall 0).
        Ẋ ≠ - Map über Paare benachbarter Elemente mit ≠ (ungleich). In Husk
              Einige Operatoren geben andere nützliche Dinge als nur Boolesche Werte zurück.
              Hier gibt ≠ die absolute Differenz zwischen den beiden Argumenten zurück.
       ∫ - Kumulative Summen.
 mo - Ordne die folgende Funktion der Summenliste zu:
    İp - Ergibt die unendliche Liste der Primzahlen.
   ! → - Und mit der aktuellen, inkrementierten Summe hinein indexieren.
Π - Nehmen Sie das Produkt.

Decoder:

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.

— Mr. Xcoder
quelle

3

Python 2 , 234 193 174 Bytes

Encoder, 116 101 97 Bytes:

Verwendet den Satz von 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

Probieren Sie es online!

Decoder, 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

Probieren Sie es online!

— ovs
quelle

1

J , 34 Bytes

Stark inspiriert von Jonathan Allans Jelly-Lösung!

Encoder: 23 Bytes

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

Probieren Sie es online!

                    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

Ich mag diese vielen Cap-Gabeln nicht [:- es sollte golffähig sein.

Decoder: 11 Bytes

2|[:_1&p:q:

Probieren Sie es online!

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

— Galen Ivanov
quelle

1

Gelee , 15 Bytes

Encoder, 9 Bytes

0;ŒgL€ÆẸH

Probieren Sie es online!

Decoder, 6 Bytes

Æf’ÆCḂ

Probieren Sie es online!

— Dennis
quelle

1

C (GCC) , 180 184 Bytes

Es wurden vier Bytes hinzugefügt, damit die Ausgabeformate übereinstimmen.

102 Bytes - Encoder

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

Probieren Sie es online!

82 Bytes - Decoder

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

Probieren Sie es online!

— Jonathan Frech
quelle

@AsoneTuhid Sorry, falsch gelesen.

— Jonathan Frech

@AsoneTuhid Nun wurde ein Decoder hinzugefügt. Hoffentlich jetzt konform.

— Jonathan Frech

@ovs True; danke für deine bemerkung.

— Jonathan Frech

1

Gol> <> , 29 + 39 = 68 Bytes

Encoder, 29 Bytes

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

Probieren Sie es online!

Decoder, 39 Bytes

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

Probieren Sie es online!

Wie diese funktionieren

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

Es wäre besser, wenn ich in der nächsten Runde Golf spielen könnte ...

— Bubbler
quelle

Prime Factor Encoding

Wie funktioniert die Kodierung?

Beispiele

Einige weitere Beispiele:

Herausforderung

Input-Output

Anmerkungen

Wertung

05AB1E , 13 Bytes

Encoder, 8 Bytes

Decoder, 5 Bytes

Gelee , 17 Bytes

Encoder (10 Bytes):

Decoder (7 Bytes):

Wie?

JavaScript (ES6), 130 Byte

Encoder, 71 Bytes

Decoder, 59 Bytes

Java 10, 209 Bytes

Encoder, 124 Bytes

Decoder, 85 Bytes

Schale , 18 Bytes

Encoder, 11 Bytes

Decoder, 7 Bytes

Wie sie arbeiten

Python 2 , 234 193 174 Bytes

Encoder, 116 101 97 Bytes:

Decoder, 118 92 77 Bytes:

J , 34 Bytes

Encoder: 23 Bytes

Decoder: 11 Bytes

Gelee , 15 Bytes

Encoder, 9 Bytes

Decoder, 6 Bytes

C (GCC) , 180 184 Bytes

102 Bytes - Encoder

82 Bytes - Decoder

Gol> <> , 29 + 39 = 68 Bytes

Encoder, 29 Bytes

Decoder, 39 Bytes

Wie diese funktionieren