Zamapuj listę o nieokreślonym rozmiarze na liczbę!

11

Dobrze wiadomo, w dziedzinie matematyki badającej nieskończoność, że iloczyn kartezjański dowolnej skończonej liczby zbiorów policzalnych jest również policzalny .

Twoim zadaniem jest napisanie dwóch programów, które to zaimplementują, jednego do mapowania z listy na liczbę całkowitą, jednego do mapowania z liczby całkowitej na listę.

Twoja funkcja musi być bijectywna i deterministyczna, co oznacza, że 1zawsze będzie mapowana na określoną listę i 2zawsze będzie mapowana na inną określoną listę itp.

Wcześniej zamapowaliśmy liczby całkowite na listę składającą się wyłącznie z 0i 1.

Jednak teraz lista będzie się składać z liczb nieujemnych.

Okular

  • Program / funkcja, rozsądny format wejścia / wyjścia.
  • Niezależnie od tego, czy zmapowane liczby całkowite zaczynają się, 1czy zaczynają od 0ciebie, zależy od ciebie, co oznacza, że 0nie musisz (ale może) mapować do niczego.
  • Pusta tablica []musi być zakodowana.
  • Wejście / wyjście może być w dowolnej bazie.
  • Udostępnianie kodu między dwiema funkcjami jest dozwolone .

Punktacja

To jest . Najniższy wynik wygrywa.

Wynik jest sumą długości (w bajtach) dwóch programów / funkcji.

Leaky Nun
źródło
„Teraz jednak lista będzie się składać z liczb nieujemnych”.
Leaky Nun
Więc, żeby być jasnym, mapujemy N^inf -> N?
Mego
@Mego N ^ inf nie można policzyć. N ^ k gdzie k jest dowolną liczbą skończoną.
Leaky Nun
Dyskutowaliśmy o tym na czacie.
Leaky Nun
Niezależnie od tego, czy zaczyna się od 1, czy od 0, należy do ciebie. Czy dotyczy to pojedynczej liczby całkowitej i liczb całkowitych z listy?
Dennis

Odpowiedzi:

10

Galaretka , 18 16 bajtów

Lista do liczb całkowitych, 10 8 bajtów

TṪạL;³ÆẸ

Odwzorowuje listy liczb całkowitych nieujemnych na liczby całkowite dodatnie. Wypróbuj online!

Liczba całkowita do listy, 8 bajtów

ÆE©Ḣ0ẋ®;

Mapuje dodatnie liczby całkowite na listy liczb całkowitych nieujemnych. Wypróbuj online!

tło

Niech p 0 , p 1 , p 2 , ⋯ będą ciągiem liczb pierwszych w porządku rosnącym.

Dla każdej listy liczb całkowitych nieujemnych A: = [a 1 , ⋯, a n ] , odwzorowujemy A na p 0 z (A) p 1 a 1 ⋯ p n a n , gdzie z (A) jest liczbą końcowe zera z A .

Odwrócenie powyższej mapy w prosty sposób. Dla dodatniej liczby całkowitej k rozkładamy ją jednoznacznie jako iloczyn kolejnych sił pierwszych n = p 0 α 0 p 1 α 1 ⋯ p n α n , gdzie α n > 0 , a następnie rekonstruujemy listę jako 1 , ⋯, α n ] , dodanie α 0 zerami.

Jak to działa

Lista do liczby całkowitej

TṪạL;³ÆẸ  Main link. Argument: A (list of non-negative integers)

T         Yield all indices of A that correspond to truthy (i.e., non-zero) items.
 Ṫ        Tail; select the last truthy index.
          This returns 0 if the list is empty.
   L      Yield the length of A.
  ạ       Compute the absolute difference of the last truthy index and the length.
          This yields the amount of trailing zeroes of A.
    ;³    Prepend the difference to A.
      ÆẸ  Convert the list from prime exponents to integer.

Liczba całkowita do listy

ÆE©Ḣ0ẋ®;  Main link. Input: k (positive integer)

ÆE        Convert k to the list of its prime exponents.
  ©       Save the list of prime exponents in the register.
   Ḣ      Head; pop the first exponent.
          If the list is empty, this yields 0.
    0ẋ    Construct a list of that many zeroes.
      ®;  Concatenate the popped list of exponents with the list of zeroes.       

Przykładowe dane wyjściowe

Pierwsze sto dodatnich liczb całkowitych mapuje na następujące listy.

  1: []
  2: [0]
  3: [1]
  4: [0, 0]
  5: [0, 1]
  6: [1, 0]
  7: [0, 0, 1]
  8: [0, 0, 0]
  9: [2]
 10: [0, 1, 0]
 11: [0, 0, 0, 1]
 12: [1, 0, 0]
 13: [0, 0, 0, 0, 1]
 14: [0, 0, 1, 0]
 15: [1, 1]
 16: [0, 0, 0, 0]
 17: [0, 0, 0, 0, 0, 1]
 18: [2, 0]
 19: [0, 0, 0, 0, 0, 0, 1]
 20: [0, 1, 0, 0]
 21: [1, 0, 1]
 22: [0, 0, 0, 1, 0]
 23: [0, 0, 0, 0, 0, 0, 0, 1]
 24: [1, 0, 0, 0]
 25: [0, 2]
 26: [0, 0, 0, 0, 1, 0]
 27: [3]
 28: [0, 0, 1, 0, 0]
 29: [0, 0, 0, 0, 0, 0, 0, 0, 1]
 30: [1, 1, 0]
 31: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
 32: [0, 0, 0, 0, 0]
 33: [1, 0, 0, 1]
 34: [0, 0, 0, 0, 0, 1, 0]
 35: [0, 1, 1]
 36: [2, 0, 0]
 37: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
 38: [0, 0, 0, 0, 0, 0, 1, 0]
 39: [1, 0, 0, 0, 1]
 40: [0, 1, 0, 0, 0]
 41: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
 42: [1, 0, 1, 0]
 43: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
 44: [0, 0, 0, 1, 0, 0]
 45: [2, 1]
 46: [0, 0, 0, 0, 0, 0, 0, 1, 0]
 47: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
 48: [1, 0, 0, 0, 0]
 49: [0, 0, 2]
 50: [0, 2, 0]
 51: [1, 0, 0, 0, 0, 1]
 52: [0, 0, 0, 0, 1, 0, 0]
 53: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
 54: [3, 0]
 55: [0, 1, 0, 1]
 56: [0, 0, 1, 0, 0, 0]
 57: [1, 0, 0, 0, 0, 0, 1]
 58: [0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
 59: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
 60: [1, 1, 0, 0]
 61: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
 62: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
 63: [2, 0, 1]
 64: [0, 0, 0, 0, 0, 0]
 65: [0, 1, 0, 0, 1]
 66: [1, 0, 0, 1, 0]
 67: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
 68: [0, 0, 0, 0, 0, 1, 0, 0]
 69: [1, 0, 0, 0, 0, 0, 0, 1]
 70: [0, 1, 1, 0]
 71: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
 72: [2, 0, 0, 0]
 73: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
 74: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
 75: [1, 2]
 76: [0, 0, 0, 0, 0, 0, 1, 0, 0]
 77: [0, 0, 1, 1]
 78: [1, 0, 0, 0, 1, 0]
 79: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
 80: [0, 1, 0, 0, 0, 0]
 81: [4]
 82: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
 83: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
 84: [1, 0, 1, 0, 0]
 85: [0, 1, 0, 0, 0, 1]
 86: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
 87: [1, 0, 0, 0, 0, 0, 0, 0, 1]
 88: [0, 0, 0, 1, 0, 0, 0]
 89: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
 90: [2, 1, 0]
 91: [0, 0, 1, 0, 1]
 92: [0, 0, 0, 0, 0, 0, 0, 1, 0, 0]
 93: [1, 0, 0, 0, 0, 0, 0, 0, 0, 1]
 94: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
 95: [0, 1, 0, 0, 0, 0, 1]
 96: [1, 0, 0, 0, 0, 0]
 97: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
 98: [0, 0, 2, 0]
 99: [2, 0, 0, 1]
100: [0, 2, 0, 0]
Dennis
źródło
To jest genialne.
Leaky Nun
3

Python 2, 88 bajtów

d=lambda n:map(len,bin(n).split('1')[1:])
e=lambda l:int('1'.join(a*'0'for a in[2]+l),2)

Próbny:

>>> for i in range(33):
...     print e(d(i)), d(i)
... 
0 []
1 [0]
2 [1]
3 [0, 0]
4 [2]
5 [1, 0]
6 [0, 1]
7 [0, 0, 0]
8 [3]
9 [2, 0]
10 [1, 1]
11 [1, 0, 0]
12 [0, 2]
13 [0, 1, 0]
14 [0, 0, 1]
15 [0, 0, 0, 0]
16 [4]
17 [3, 0]
18 [2, 1]
19 [2, 0, 0]
20 [1, 2]
21 [1, 1, 0]
22 [1, 0, 1]
23 [1, 0, 0, 0]
24 [0, 3]
25 [0, 2, 0]
26 [0, 1, 1]
27 [0, 1, 0, 0]
28 [0, 0, 2]
29 [0, 0, 1, 0]
30 [0, 0, 0, 1]
31 [0, 0, 0, 0, 0]
32 [5]

Python 2, 130 bajtów

Oto bardziej „wydajne” rozwiązanie, w którym długość bitu wyjścia jest liniowa na długości bitu wejścia, a nie wykładnicza.

def d(n):m=-(n^-n);return d(n/m/m)+[n/m%m+m-2]if n else[]
e=lambda l:int('0'+''.join(bin(2*a+5<<len(bin(a+2))-4)[3:]for a in l),2)
Anders Kaseorg
źródło
Używa tego samego algorytmu, co moje rozwiązanie :)
Leaky Nun
@KennyLau: Nie spojrzałem na twoje rozwiązanie. Wyglądają podobnie, ale nie identycznie (0 i 1 są zamieniane). A twojemu nie udaje się w obie strony pustej listy.
Anders Kaseorg
Rozumiem, dzięki za przypomnienie.
Leaky Nun
Nawiasem mówiąc, powiedziałem, że wyjście może być w dowolnej bazie.
Leaky Nun
Ponieważ kod podziału między funkcjami jest dozwolone, to wygląda jak można po prostu zbudować esię odwrotność dla d: e=lambda l,i=0:l!=d(i)and-~e(l,i+1).
xnor
1

Python 2, 204 202 bajty

p=lambda x,y:(2*y+1<<x)-1
u=lambda n,x=0:-~n%2<1and u(-~n//2-1,x+1)or[x,n//2]
e=lambda l:l and-~reduce(p,l,len(l)-1)or 0
def d(n):
 if n<1:return[]
 r=[];n,l=u(n-1);exec"n,e=u(n);r=[e]+r;"*l;return[n]+r

Działa poprzez wielokrotne stosowanie bijectcji Z + x Z + <-> Z +, poprzedzone długością listy.

0: []
1: [0]
2: [1]
3: [0, 0]
4: [2]
5: [0, 0, 0]
6: [1, 0]
7: [0, 0, 0, 0]
8: [3]
9: [0, 0, 0, 0, 0]
10: [1, 0, 0]
11: [0, 0, 0, 0, 0, 0]
12: [0, 1]
13: [0, 0, 0, 0, 0, 0, 0]
14: [1, 0, 0, 0]
15: [0, 0, 0, 0, 0, 0, 0, 0]
16: [4]
17: [0, 0, 0, 0, 0, 0, 0, 0, 0]
18: [1, 0, 0, 0, 0]
19: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
20: [0, 0, 1]
21: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
22: [1, 0, 0, 0, 0, 0]
23: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
24: [2, 0]
25: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
26: [1, 0, 0, 0, 0, 0, 0]
27: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
28: [0, 0, 0, 1]
29: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
30: [1, 0, 0, 0, 0, 0, 0, 0]
31: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
orlp
źródło
Jedno pytanie: która funkcja jest funkcją „lista do liczb całkowitych”, a która jest funkcją „liczb całkowitych do listy”?
user48538
@ zyabin101 ejest listą do liczby całkowitej, djest liczbą całkowitą do listy (kodowanie / dekodowanie).
orlp
Podoba mi się to rozwiązanie.
Leaky Nun