Question

我一直在扫描互联网，尝试为这个简单的程序提供解决方案，基本上用户输入数字（电话号码）并根据以下规则更改每个号码：

0→（变成）5,1→9,2→8,3,4,4→6,5→0,6→4,7→3,8→2,9→1。

因此7784321600的数量变为3326789455。

我将用户输入作为String，将其转换为int数组但是当我尝试交换时，我不能让它像我希望的那样工作。

我尝试用以下方式交换值：

for (int i = 0; i < input.length(); i++) {
    if (nrArray[i] == 0) {
        // 0 becomes 5
        int temp0[] = { 5 };
        nrArray[i] = nrArray[i] + temp0[i];
        temp0[i] = nrArray[i] - temp0[i];
        nrArray[i] = nrArray[i] - temp0[i];
    }
}

如果它只是交换数字0-4就可以正常工作，只要它达到5-9，代码就会再次反转它：

for (int i = 0; i < input.length(); i++) {
    if (nrArray[i] == 5) {
        // 5 becomes 0
        int temp0[] = { 0 };
        nrArray[i] = nrArray[i] + temp0[i];
        temp0[i] = nrArray[i] - temp0[i];
        nrArray[i] = nrArray[i] - temp0[i];
    }
}

我还尝试使用replaceAll方法来更改字符串，但是会出现同样的问题。

有什么建议吗？

Answer 1

到目前为止，所有答案都集中在为您提供可行的代码;没有人告诉你为什么你当前的代码不起作用。

你得到的结构是这样的：

if (a[i]==0) { a[i]=somefixedvalue }
if (a[i]==1) { a[i]=someothervalue }
if (a[i]==2) { a[i]=somethirdvalue }
//etc.

这里的问题是所有你的语句被逐一执行。如果第一个将a[i]的值更改为1，那么第二个也将通过警卫并再次更改。

你真正想要的是说应该执行其后卫匹配的第一个语句，之后它应该停止。正确的模式是

if (a[i]==0) { a[i]=somefixedvalue }
else if (a[i]==1) { a[i]=someothervalue }
else if (a[i]==2) { a[i]=somethirdvalue }
//etc.

解决方案有更简洁的方法，包括存储固定的地图或使用switch声明，但希望这可以回答您的问题，即为什么您的代码无法正常工作。

Answer 2

一个简单的解决方案是使用固定的map：

{0: 5, 1: 9, 2: 8, 3: 7, 4: 6, 5: 0, 6: 4, 7: 3, 8: 2, 9: 1}

然后您只需迭代序列，对于每个字符ch，您将其替换为map[ch]。

解决方案的复杂性是O（n），你可以拥有的最好。

伪代码：

res = ""
for ch in seq:
    res += map[ch]

Answer 3

使用散列映射将源整数存储为键，将目标整数存储为值。然后迭代遍历数组，在每次迭代期间从hashmap获取当前数组值目标并替换它。

int a[] = {7,7,8,4,3,2,1,6,0,0};
Map<Integer, Integer> map = new HashMap<Integer, Integer>();

//0->5, 1->9, 2->8, 3->7, 4->6, 5->0, 6->4, 7->3, 8->2, 9->1
map.put(0, 5);
map.put(1, 9);
map.put(2, 8);
map.put(3, 7);
map.put(4, 6);
map.put(5, 0);
map.put(6, 4);
map.put(7, 3);
map.put(8, 2);
map.put(9, 1);

for (int i = 0; i < a.length; i++) {
    a[i] = map.get(a[i]);
}

Answer 4

使用整数数组，您可以创建便宜且快速的地图，您可以使用该地图来映射输入＆lt; - ＆gt;你的愿望输入。此外，使用stringbuilder可以创建数字的字符串表示形式，然后将其解析为int

int [] switcher = {5,9,8,7,6,0,4,3,2,1};

    int [] input;
    StringBuilder wholeNumber = new StringBuilder();
    for(int i = 0; i < input.length; i++)
    {
        input[i] = switcher[input[i]];
        wholeNumber.append(String.valueOf(input[i]));
    }

    int wholeNumberInt = Integer.parseInt(wholeNumber.toString());

Answer 5

您还可以使用替换每个数组元素的Switch语句来实现目标。此示例检查每个元素并用正确的数字替换它，然后打印出结果数组。

    int arr[] = {4,0,7,8,8,5,0,0,9,0};
    for(int i=0; i<arr.length;i++){
        switch(arr[i]){
            case 0:
                arr[i] = 5;
                break;
            case 1:
                arr[i] = 9;
                break;
            case 2:
                arr[i] = 8;
                break;
            case 3:
                arr[i] = 7;
                break;
            case 4:
                arr[i] = 6;
                break;
            case 5:
                arr[i] = 0;
                break;
            case 6:
                arr[i] = 4;
                break;
            case 7:
                arr[i] = 3;
                break;
            case 8:
                arr[i] = 2;
                break;
            case 9:
                arr[i] = 1;
                break;
            }
    }
    for(int i =0; i<arr.length;i++) {
        System.out.println(arr[i]);
    }
}

Answer 6

在您的情况下，您可以使用以下条件

   if(nrArray[i]%5 == 0) {
     nrArray[i]= 5-nrArray[i];
    }
   else{
     nrArray[i]= 10-nrArray[i];
    }

Answer 7

只有一个for循环，包含if-else语句中的所有数字开关。循环只对阵列中的每个数字运行一次，因此不会将5更改为0并再次返回到5，就像你的一样。

for(int i=0; i<input.length(); i++){
    if(nrArray[i]==0){
        nrArray[i]=5;
    }else if(nrArray[i]==5){
        nrArray[i]=0;
    }//All the other else-if for the different number switches
}

因为您使用else if语句，所以只会为数组中的每个数字运行一个块。

Answer 8

由于它不是逻辑分割（即0 <-> 9; 1 <-> 8; 2 <-> 7; 3 <-> 6; 4 <-> 5），我认为可能选择是使用这样的地图：

import java.util.HashMap;
import java.util.Map;

public class Main
{
    private static final Map<Character, Character> map = new HashMap<Character, Character>() {
        private static final long serialVersionUID = 1L;

        {
            put('0', '5');
            put('1', '9');
            put('2', '8');
            put('3', '7');
            put('4', '6');
            put('5', '0');
            put('6', '4');
            put('7', '3');
            put('8', '2');
            put('9', '1');
        }
    };

    public static void main(final String[] args) {

        final String aNumber = "7784321600";

        char[] list = aNumber.toCharArray();
        String result = "";
        for (final char ch : list) {
            result += map.get(ch);
        }

        System.out.println("Before: " + aNumber);
        System.out.println("After: " + result);
    }
}

输出：

Before: 7784321600
After: 3326789455

Answer 9

如果你想要一些简单明了的东西......你可以将输入存储在一个int数组中并执行此操作

int[] input = {1, 2, 3, 4, 5, 6, ,7 ,8, 9, 0};
int[] encoded = new int[input.length];

for(int i=0; i < encoded.length; i++)
{
    if (input[i] == 5)
    {
      encoded[i] = 0;
      continue;
    }

    if (input[i] == 0)
    {
      encoded[i] = 5;
      continue;
    }

    encoded[i] = 10 - input[i]; 
}

您的编码似乎遵循除0和5之外的模式。我认为无需映射所有值。你只需要映射那些不适合模式的那些。

Answer 10

复杂度为O(n)的解决方案之一是简单地将新值存储在数组中，并在迭代时将其替换为输入磁带。

我将用户输入作为String，将其转换为int数组

没有明确需要将输入String转换为int数组。

以下是代码段：

public static void main (String[] args) throws Exception {
    int[] arr = {5,9,8,7,6,0,4,3,2,1};
    String input = "7784321600";
    for(char c : input.toCharArray()) {
        System.out.print(arr[Character.getNumericValue(c)]);
    }
    System.out.println();
}

输出：

3326789455

Answer 11

我相信这就是你的目标。

只需使用当前数字的值作为键数组的索引。这将找到它转换为的相应值。

public class NumberEncoder {
    private static final int[] KEY = { 5, 9, 8, 7, 6, 0, 4, 3, 2, 1 };

    public static void main(String[] args) {
        System.out.println(encode(125, KEY)); // 980
    }

    public static int encode(int n, int[] key) {
        String input = Integer.toString(n);
        StringBuffer result = new StringBuffer();

        for (int i = 0; i < input.length(); i++) {
            result.append(key[Character.getNumericValue(input.charAt(i))]);
        }

        return Integer.parseInt(result.toString());
    }
}

如果您需要处理大于长值的较大数字，可以使用BigInteger。

import java.math.BigInteger;

public class NumberEncoder {
    private static final int[] KEY = { 5, 9, 8, 7, 6, 0, 4, 3, 2, 1 };

    public static void main(String[] args) {
        System.out.println(encode(new BigInteger("123456789012345678901234567890"), KEY));
    }

    public static BigInteger encode(BigInteger value, int[] key) {
        String input = value.toString();
        StringBuffer result = new StringBuffer();

        for (int i = 0; i < input.length(); i++) {
            result.append(key[Character.getNumericValue(input.charAt(i))]);
        }

        return new BigInteger(result.toString()); // 987604321598760432159876043215
    }
}

根据模式切换int数组中的数字

11 个答案: