Java 将（x，y）映射到单个数值

我想要一个函数来将（x，y）值映射到单个数值，并在Java中进行相应的反向映射

例如，（2,34）应该映射到某个值100，如果我们有100，我们应该能够找到（2,34）。

您应该看看。

---

类似于

HashMap

的东西似乎适合您的情况。

好吧，如果其中一个有一个最大值，那么是的。假设

y

限制为0…9999，则可以执行以下操作：

int num = x * 10000 + y;

（当然，假设结果适合该类型-如果需要，您可以升级到更广泛的类型，如

long

）。然后，回到过去：

int x = num / 10000;
int y = num % 10000;

---

你可以把它们当作一根绳子

String a = "(2,34)";
String b = "100";

Map<String, String> m = new HashMap<String, String>();
m.put(a, b);
m.put(b, a);

/*print*/
System.out.println(m.get(a));
System.out.println(m.get(b));

String a=“（2,34）”；
字符串b=“100”；
Map m=新的HashMap（）；
m、 put（a，b）；
m、 付诸表决（b，a）；
/*印刷品*/
系统输出println（m.get（a））；
系统输出println（m.get（b））；

此要求的背景是什么

如果x、y值的范围是无限的，则无法以唯一的方式执行此操作（以便始终可以反转此过程）

---

如果数字的范围是有限的，那么您可以执行以下操作：假设x和y都是

int

值，范围都在0到99之间。然后通过以下公式计算结果：

z=100*x+y

。反之亦然：

x=z/100

和

y=z%100

如果你有一个上限（比如

100

是

（x，y）

中

x

的较高值），那么你可以将任何

n

与一对

（x，y）

值关联，这个函数是：

n=x*100+y

如果你没有任何限制，事情就会变得更困难。将属于

R

的数字与

R^2

的数字相关联的一种方法是枚举对角线。看看这个例子，它是一个矩阵，其中

（x，y）

单元格包含与其关联的

n

：

1  2  4  7  11 ..
3  5  8  12 ..
6  9  13 ..
10 ..
..

---

基于paxdiablo答案的另一种策略是使用小数点，因此您可以将x分量放在小数点之前，将y分量放在小数点之后

---

这可能需要一些混乱的字符串处理，但没有限制，您需要能够绑定一个坐标。

记住，原始数字只是一堆原始位。如果您的数字是32位整数（

int

），您可以方便地将其中两个数字打包成一个64位整数（

long

）。大概是这样的：

int a = 3;
int b = 4;
long c = ((long) a) << 16 | b;

...

a = (int) (c >> 16);
b = (int) (c & 0xffff);

inta=3；
int b=4；
长c=（（长）a）>16）；
b=（int）（c&0xffff）；

公共类哈希{
公共静态void main（字符串args[]）引发IOException
{
HashMap g=新的HashMap（）；
列表xys=新的ArrayList（）；
List ss=new ArrayList（）；
System.out.println（“在（x，y）中输入坐标”）；
BufferedReader reader=新的BufferedReader（新的InputStreamReader（System.in））；
系统输出打印项次（“x”）；
int n1=Integer.parseInt（reader.readLine（））；
系统输出打印项次（“y”）；
int n2=Integer.parseInt（reader.readLine（））；
xys.添加（n1）；
xys.添加（n2）；
intd=（int）（Math.pow（xys.get（0），xys.get（1））；
ss.添加（d）；
g、 put（xys，ss）；
g、 put（ss，xys）；
列表r=g.get（ss）；
列表r1=g.get（xys）；
System.out.print（“值（x，y）映射的哈希”）；
系统输出打印（r1）；
System.out.print（“值N的哈希，反向映射”）；
系统输出println（r）；
}
}

这是不正确的。该函数接受2个变量或1个？x和y的可能值范围是多少？如果计算结果大于一个整数所能容纳的范围，则该函数将失败。“num”也需要保持在整数范围内。@fatih，我认为他们必须“适合”，我会澄清答案。@paxdiableo同意。只是想指出一个可能没有提到的缺陷。现在你也提到了：）我已经创建了一个函数f（x，y）作为x^y，我的问题是x的范围是0到1000，y是0到1000，它不适合int，也就是说（如果（234567）是234^567）。我想要一个散列函数f（x，y），它将返回不长的整数。即使x和y的范围是无限的，它也是可能的。考虑康托对理性的列举，为什么会被否决呢？这基本上与paxdiablo给出的最高评级答案相同（我们同时给出了答案）。Mwahhh-为什么我被否决了？请给我反馈，因为我是一个傻瓜，正在学习我的方法。我认为我的贡献是有效的！我的想法是：浮点数并不理想，因为它们可以被截断，特别是小数部分。因此，一旦开始提取，可能会出现一些舍入错误，提取后原来是（9999999999）的结果是（9999999998）。这来得有点晚了，但为什么只让移位16？容纳32位整数

b

不应该是32吗？

public class hash {
public static void main(String args[]) throws IOException
    {
    HashMap<List<Integer>,List<Integer>> g=new HashMap<List<Integer>,List<Integer>>();
    List<Integer> xys=new ArrayList<Integer>();
    List<Integer> ss=new ArrayList<Integer>();
    System.out.println("Enter the coordinates in (x,y)");
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
System.out.println("x");
    int n1=Integer.parseInt(reader.readLine());
    System.out.println("y");

    int n2=Integer.parseInt(reader.readLine());
    xys.add(n1);
    xys.add(n2);
    int d=(int)(Math.pow(xys.get(0),xys.get(1)));

    ss.add(d);

   g.put(xys,ss);
   g.put(ss,xys);
        List<Integer> r= g.get(ss);

        List<Integer> r1=g.get(xys);

        System.out.print("Hash for the value (x,y) mapping");
        System.out.print(r1);


        System.out.print("Hash for the value N, reverse mapping");
        System.out.println(r);


}
}