【问题标题】:Splitting integers in arrays to individual digits将数组中的整数拆分为单个数字
【发布时间】:2011-02-12 22:39:52
【问题描述】:

我有一个数组:

int test[]={10212,10202,11000,11000,11010};

我想将 inetger 值拆分为单个数字并将它们作为单个元素放入一个新数组中,这样我的数组现在是:

int test2[]={1,0,2,1,2,1,0,2,0,2,1,1,0,0,0,1,1,0,0,0,1,1,0,1,0};

我该怎么做呢?我在java中这样做。

谢谢。

【问题讨论】:

  • 所有数字都在 10000 - 19999 范围内吗?或者:前导零怎么样?

标签: java arrays split integer


【解决方案1】:

您将取每个整数,除以 10 并将小数与余数分开。将分数乘以 10 使其再次成为整数并将其放入新数组中。重复直到你的数字用完。重复直到输入数组中的整数用完为止。

【讨论】:

  • 另外,你最终会使用这种方法或@Timmmm's 反转每个数字的数字......我认为使用基于字符串的方法会更简单(正如 Joachim 指出的那样,没有表明性能是一个问题)。
【解决方案2】:

试试这样的。

{
  int test[]={10212,10202,11000,11000,11010};
  int test2[] = new int[25];
  int i = 24;

  int temp;
  for(int n = test.size() - 1; n >= 0; n--){
    temp = test[n];
    while(temp > 0){
      test2[i--] = test % 10; // <= Gets remainder of division by 10.
      test /= 10; // <= Stores the integer result of the division.
    }
  }
}

我没有测试过这段代码。

此代码将忽略前导零(自然)并回填整数数组。为数组获取合适的大小可能是个问题。

【讨论】:

    【解决方案3】:

    您可以按照 Mark 的建议进行操作,或者将它们转换为 String 以获得单个数字:

    int test[]={10212,10202,11000,11000,11010};
    ArrayList<Integer> test2 = new ArrayList<Integer>();
    
    for (int i : test)
    {
      String str = String.valueOf(i);
      for (int j = 0; j < str.length(); ++j)
        test2.add((int)(str.charAt(j)-'0'));
    }
    

    由于仍然涉及字符串的内存效率更高的方法是将所有数字保留为一个字符串并即时计算 int 值:

    class Digits
    {
      String str;
    
      Digits(int[] nums)
      {
        StringBuilder sb = new StringBuilder();
        for (int i : nums)
          sb.append(String.valueOf(i));
    
        str = sb.toString();
      }
    
      int length()
      {
        return str.length();
      }
    
      int nth(int i)
      {
        return (int)(str.charAt(i)-'0');
      }
    }
    

    请注意,CheesePls 解决方案是正确的 解决方案,因为它使用了预期使用的数学。我的只是给新手(并且只是为了解决这个问题提供另一种方法)..

    【讨论】:

    • 从一个字符串来回转换它会非常低效。
    • @zipcodeman:就像将每个数字存储在自己的 int 中一样。那你的意思是什么?
    • String 不需要参与。
    • 我想我们不是在谈论效率,这只是为了建议一种替代方式。大家应该都知道,相比生成字符串,使用取模和除法效率更高。但这不是重点.. 用户并没有要求一种有效的方法.. 请发挥创造力,尤其是在谈论除非使用数百万个整数不会影响效率的事情时。
    • 使用字符串绝对没有错。当涉及到实际编码时,字符串往往会使事情变得更加复杂(并且令人讨厌),这是避免这种方式的唯一真正原因。
    【解决方案4】:

    这个(未经测试):

    int test[] = {10212,10202,11000,11000,11010};
    ArrayList<Integer> test2 = new ArrayList<Integer>();
    
    for (int i : test)
    {
      int p = test2.size();
      while (i > 0)
      {
         test2.add(p, i % 10);
         i /= 10;
      }
    }
    

    【讨论】:

      【解决方案5】:

      这是一种使用字符串的方法。不是特别高效,但(我希望)易于理解。

      package playground.tests;
      
      import junit.framework.TestCase;
      
      public class SplitIntegerTest extends TestCase {
      
          public void testIntsFromOneInteger() throws Exception {
              assertEqualArrays(new int[] { 1, 0, 2, 1, 2 }, intsFrom(10212));
          }
      
          public void testIntsFromArray() throws Exception {
              int test[] = { 10212, 10202, 11000, 11000, 11010 };
      
              int test2[] = { 1, 0, 2, 1, 2, 1, 0, 2, 0, 2, 1, 1, 0, 0, 0, 1, 1, 0,
                      0, 0, 1, 1, 0, 1, 0 };
      
              assertEqualArrays(test2, intsFrom(test));
          }
      
          private int[] intsFrom(int[] input) {
              int[][] list = new int[input.length][];
              for (int i = 0; i < input.length; i++)
                  list[i] = intsFrom(input[i]);
              int n = 0;
              for (int[] array : list)
                  n += array.length;
              int[] result = new int[n];
              int index = 0;
              for (int[] array : list)
                  for (int i : array)
                      result[index++] = i;
              return result;
          }
      
          private static int[] intsFrom(Integer n) {
              String s = n.toString();
              int[] result = new int[s.length()];
              for (int i = 0; i < result.length; i++)
                  result[i] = intFrom(s.charAt(i));
              return result;
          }
      
          private static int intFrom(Character c) {
              return Integer.parseInt(c.toString());
          }
      
          private static void assertEqualArrays(int[] a, int[] b) {
              assertEquals(a.length, b.length);
              for (int i = 0; i < b.length; i++)
                  assertEquals(a[i], b[i]);
          }
      
      }
      

      【讨论】:

        【解决方案6】:
        int[] test={10212,10202,11000,11000,11010};
        ArrayList<Integer> test2 = new ArrayList<Integer>();
        
        
        for(int i = test.length -1; i >= 0; i--){
            int temp = test[i];
            while(temp>0){
                test2.add(0, temp%10);  //place low order digit in array
                temp = temp /10;        //remove low order digit from temp;
            }
        }
        

        这将完全符合您的要求,方法是将条目的最低位数字放入数组列表的“前面”,因此位于之前的低位数字/条目的前面。

        如果你需要它在一个数组中,ArrayList 有一个 toArray 方法。

        【讨论】:

        • 这比 Jack 的解决方案更节省内存,因为不需要中间字符串,但一些开发人员可能很难理解它。在大多数情况下,我会选择 Jack's,但我会投票给这个。
        • 我不明白向后遍历数组或基本整数操作有什么困难。它与倒计时或五年级数学一样基本。 - 但是,是的,如果你不习惯阅读 for 语句可能会很棘手。
        • @neilwhitaker1:如果开发人员在理解这段基本代码时遇到问题,那么他们显然不是面向数学的根本(因为这真的很基础),也许他们应该,好吧,要么开始学习,要么开始寻找另一份工作; )
        【解决方案7】:

        几乎是单行的(如果我们假设有一个开箱即用的函数可以将字符串数组转换为整数数组):

        int test[]={10212,10202,11000,11000,11010};
        int result[] = strArray2IntArray (
                          Arrays.toString (test)
                         .replaceAll ("\\D", "")
                         .replaceAll ("(\\d)", "$1 ")
                         .split (" ")
                       );
        

        private static int[] strArray2IntArray (String[] array) {
            int[] result = new int[array.length];
            for (int i = 0; i < result.length; i++) {
                result[i] = Integer.parseInt (array[i]);
            }
            return result;
        }
        

        【讨论】:

          【解决方案8】:
              package Map;
              import java.util.ArrayList;
              public class Practice7 { 
                  public void testing() {
                      int test[] = {10212,10202,11000,11000,11010};
                      ArrayList<Integer> temp = new ArrayList<>();
                      StringBuilder sb = new StringBuilder();
                      for(int i=0;i<test.length;i++){
                          if(test[i]>0){
              
                              sb.append(test[i]);
                              String s= sb.toString();
                              //System.out.println(s);
                              for(int m=0;m<s.length();m++){
                                  //System.out.println(s.charAt(m));
                                  temp.add((int) s.charAt(m)-'0');
                              }
              
                              for(int b: temp){
                                  System.out.println(b);
                              }
              
                          }
                      }
              
              
              
              
              
                  }
                  public static void main(String[] args) {
                      Practice7 practice7= new Practice7();
                      practice7.testing();
              
              
                  }
              }
          

          【讨论】:

            猜你喜欢
            • 1970-01-01
            • 2017-05-23
            • 1970-01-01
            • 1970-01-01
            • 1970-01-01
            • 2010-12-26
            • 2016-11-28
            • 1970-01-01
            • 1970-01-01
            相关资源
            最近更新 更多