Es bien sabido que hay correspondencias uno a uno entre pares de enteros y los enteros positivos. Su tarea es escribir el código que define dicha correspondencia (definiendo un par de funciones / programas que son inversos entre sí) en el lenguaje de programación de su elección, más una verificación de corrección (ver más abajo) con el menor número de bytes para la correspondencia definición (sin tener en cuenta la verificación de corrección).
La solución debe incluir:
La definición de una función / programa f que tiene dos argumentos enteros y devuelve un entero (esa es una dirección de la biyección).
ya sea la definición de una función / programa g que tiene un argumento entero y devuelve un par de enteros (podría ser una matriz, una lista, la concatenación de los dos enteros separados por algo ...) o dos funciones / programas ayb que tienen un argumento entero y devolver un entero (esa es la otra dirección).
un fragmento de código adicional que comprueba que para f y g (o f y a, b) que definió anteriormente, tiene g (f (x, y)) = (x, y) (o a (f (x, y) ) = x y b (f (x, y)) = y) para cualquier número entero x, y en el rango -100 <x <100, -100 <y <100. Tenga en cuenta que f y g tienen que trabajar para valores fuera de de este rango también.
Puede cambiar el nombre de a, b, f o g, por supuesto. Las dos soluciones no tienen que estar escritas en el mismo idioma.
A continuación se muestra una solución no óptima en absoluto en PARI / GP, con 597 caracteres para las definiciones de funciones.
plane_to_line(x,y)={
my(ax,ay,z);
ax=abs(x);
ay=abs(y);
if((ax<=ay)*(y<0), z=4*y*y-2*y+x+2;);
if((ax<=ay)*(y>=0), z=4*y*y-2*y-x+2;);
if((ay<=ax)*(x<0), z=4*x*x -y+2;);
if((ay<=ax)*(x>=0)*(y<0), z=4*x*x+4*x+y+2;);
if((ay<=ax)*(x>=0)*(y>=0),z=4*x*x-4*x+y+2;);
if((x==0)*(y==0),z=1;);
return(z);
}
line_to_plane(z)={
my(l,d,x,y);
l=floor((1+sqrt(z-1))/2);
d=z-(4*l*l-4*l+2);
if(d<=l,x=l;y=d;);
if((l<d)*(d<=3*l),x=2*l-d;y=l;);
if((3*l<d)*(d<=5*l),x=(-l);y=4*l-d;);
if((5*l<d)*(d<=7*l),x=d-6*l;y=(-l););
if((7*l<d)*(d<8*l) ,x=l;y=d-8*l;);
if(z==1,x=0;y=0;);
return([x,y]);
}
y el código de verificación de corrección:
accu=List([])
m=100;
for(x=-m,m,for(y=-m,m,if(line_to_plane(plane_to_line(x,y))!=[x,y],\
listput(accu,[x,y]);)))
Vec(accu)
fuente
Z^nde lasntuplas es que el operador omitido no es la multiplicación (en pares) sino el producto cartesiano.Z^2 = ZxZ.Respuestas:
MATL ,
4336 bytesUtiliza la función
spiral(1YL), que genera una matriz 2D cuadrada de tamaño dado con valores dispuestos en una espiral hacia afuera. Por ejemplo, con entrada7produceEl centro de la matriz, que contiene
1, corresponde a la tupla[0 0]. La esquina superior izquierda corresponde a[-3 -3]etc. Entonces, por ejemplo, f (-3, -3) será 43 yg (43) será [-3 -3].El código genera una matriz 2D con esta matriz espiral, tan grande como sea necesario para realizar la conversión. Tenga en cuenta que los tamaños más grandes siempre dan el mismo resultado para las entradas ya incluidas en tamaños más pequeños.
De Z 2 a N (18 bytes):
Pruébalo en línea!
De N a Z 2 (
2518 bytes)Pruébalo en línea!
Fragmento para verificar
Tenga en cuenta que
Gdebe modificarse para acomodar el hecho de que no tenemos una sola entrada. El código es lento, por lo que el enlace verifica las tuplas con valores de -9 a 9 solamente. Para -99 a 99, simplemente reemplace la primera línea.El código prueba cada tupla con valores en el rango definido. Realiza la conversión a un número, luego de ese número a una tupla, y luego comprueba si la tupla original y la recuperada son iguales. Todos los resultados deberían ser
1, lo que indica que todas las comparaciones dantrue.Lleva un tiempo correr.
Pruébalo en línea!
fuente
JavaScript (ES6), 171 bytes
Cambio de bits: los números negativos tienen sus bits invertidos; cada número entero se duplica y se agrega 1 si originalmente era negativo; Los bits de los enteros se intercalan. La operación inversa elimina bits alternativos, divide por 2 y voltea todos los bits si el valor era negativo. Podría ahorrar 3 bytes limitándome a valores de 15 bits en lugar de valores de 16 bits.
Mostrar fragmento de código
fuente
Gelatina,
50484645434039 bytesPlano a línea (
181716 bytes ):Pruébalo en línea!
Línea a plano (
323029272423 bytes ):Pruébalo en línea!
Explicación:
Solo lo explicaré
plane to line, porqueline to planees todo lo contrario.En primer lugar, convertimos cada número entero a un número natural, por la función
f(x) = 2*|x| - (x<0).Luego, convertimos los dos números naturales en otros dos números naturales, por la función
g(x,y) = (x+y,y).Finalmente, los convertimos en un número natural, por la función
h(x,y) = (x+1)C2 + yfuente
7