Skip to content

Eins-zu-eins-Entsprechung zwischen Paaren von ganzen Zahlen und den positiven ganzen Zahlen

Lösung:

MATL, 43 36 Byte

Dies verwendet die spiral (1YL)-Funktion, die ein quadratisches 2D-Array einer bestimmten Größe mit Werten erzeugt, die in einer nach außen gerichteten Spirale angeordnet sind. Zum Beispiel mit Eingabe 7 es produziert

43 44 45 46 47 48 49
42 21 22 23 24 25 26
41 20  7  8  9 10 27
40 19  6  1  2 11 28
39 18  5  4  3 12 29
38 17 16 15 14 13 30
37 36 35 34 33 32 31

Das Zentrum des Arrays, das enthält 1, entspricht dem Tupel [0 0]. Die obere linke Ecke entspricht [-3 -3] usw. Also zum Beispiel F (-3,-3) wird 43 und g (43) wird sein [-3 -3].

Der Code erzeugt mit dieser Spiralmatrix ein 2D-Array, das so groß ist, wie es für die Konvertierung benötigt wird. Beachten Sie, dass größere Größen immer das gleiche Ergebnis für die bereits in kleineren Größen enthaltenen Einträge liefern.

Von Z2 zu n (18 Byte):

|X>tEQ1YLGb+QZ}3$)

Probieren Sie es online aus!

|X>   % input is a 2-tuple. Take maximum of absolute values
tEQ   % duplicate. Multiply by 2 and increase by 1. This gives necessary size of spiral
1YL   % generate spiral
G     % push input 2-tuple again
b+Q   % bubble up, add, increase by 1. This makes the center correspont to [0 0]
Z}    % split tuple into its values
3$)   % use those two value as indices into the spiral array to obtain result

Von n zu Z2 (25 18 Byte)

Eqt1YLG=2#fhw2/k-q

Probieren Sie es online aus!

Eq      % input is a number. Multiply by 2, add 1. This assures size is enough and odd
t1YL    % duplicate. Generate spiral of that size
G=      % compare each entry with the input value
2#fh    % 2-tuple of row and column indices of matching entry
w2/k-q  % swap. Offset values so that center corresponds to [0 0]

Schnipsel zum Prüfen

Beachten Sie, dass G muss geändert werden, um der Tatsache Rechnung zu tragen, dass wir keinen einzigen Eingang haben. Der Code ist langsam, daher überprüft der Link nur Tupel mit Werten von -9 bis 9. Bei -99 bis 99 ersetzen Sie einfach die erste Zeile.

Der Code testet jedes Tupel mit Werten im definierten Bereich. Es führt die Umwandlung in eine Zahl durch, dann von dieser Zahl zurück in ein Tupel und prüft dann, ob das ursprüngliche und das wiederhergestellte Tupel gleich sind. Die Ergebnisse sollten alle sein 1, was darauf hinweist, dass alle Vergleiche true.

Es dauert eine Weile zu laufen.

Probieren Sie es online aus!

-9:9                     % Or use -99:99. But it takes long
HZ^!"@                   % Cartesian power: gives tuples [-9 -9] ... [9 9].
                         % For each such tuple
|X>[email protected]+QZ}3$)       % Code from Z^2 to N with `G` replaced by `@` (current tuple)
XJ                       % Copy result into clipboard J
Eqt1YLJ=2#fhw2/k-q       % Code from N to Z^2 with `G` replaced by `J`
@!X=                     % Compare original tuple with recovered tuple: are they equal?

JavaScript (ES6), 171 Byte

(x,y)=>(h=x=>parseInt((x^x>>31).toString(2)+(x>>>31),4),h(x)*2+h(y))
x=>(h=x=>parseInt(x.toString(2).replace(/.(?!(..)*$)/g,''),2),i=x=>x<<31>>31^x>>>1,[i(h(x>>>1)),i(h(x))])

Bit-Twiddling: Bei negativen Zahlen werden die Bits umgedreht; jede ganze Zahl wird dann verdoppelt und 1 hinzugefügt, wenn sie ursprünglich negativ war; die Bits aus den ganzen Zahlen werden dann verschachtelt. Die umgekehrte Operation löscht alternative Bits, dividiert durch 2 und dreht alle Bits um, wenn der Wert negativ war. Ich könnte 3 Byte sparen, indem ich mich auf 15-Bit-Werte anstelle von 16-Bit-Werten beschränke.

f=(x,y)=>(h=x=>parseInt((x^x>>31).toString(2)+(x>>>31),4),h(x)*2+h(y))
g=x=>(h=x=>parseInt(x.toString(2).replace(/.(?!(..)*$)/g,''),2),i=x=>x<<31>>31^x>>>1,[i(h(x>>>1)),i(h(x))])
for(i=-100;i<=100;i++)for(j=-100;j<100;j++)if(g(f(i,j))[0]!=i||g(f(i,j))[1]!=j)alert([i,j])

Gelee, 50 48 46 45 43 40 39 Byte

Ebene zu Linie (18 17 16 Byte):

AḤ_<0$
+RS+
,Ñç/

Probieren Sie es online aus!

Linie zu Ebene (32 30 29 27 24 23 Byte):

HĊN⁸¡
³R‘R’U⁹¡F³ịÇ
ç1,¢

Probieren Sie es online aus!

Erläuterung:

Ich werde es nur erklären plane to line, da line to plane ist genau das Gegenteil.

Zuerst wandeln wir jede ganze Zahl in eine natürliche Zahl um, mit der Funktion f(x) = 2*|x| - (x<0).

Dann wandeln wir die beiden natürlichen Zahlen in zwei weitere natürliche Zahlen um, mit der Funktion g(x,y) = (x+y,y).

Schließlich wandeln wir sie mit der Funktion . in eine natürliche Zahl um h(x,y) = (x+1)C2 + y

Click to rate this post!
[Total: 0 Average: 0]



Anderer Beitrag

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.