根據模式切換int數組中的數字

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

一個簡單的解決方案是擁有固定的地圖 ：

{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

使用整數數組，您可以創建一個便宜且快速的地圖，您可以使用它來映射輸入< - >您的願望輸入。 此外，使用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());
    }
}

如果需要處理大於long值的較大數字，可以使用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
    }
}