Appending Integer array elements in Java

Question

I have an array, say

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

I need to append each of the 5 neighboring elements and assign them to a new array b with length=(a.length/5); and i want to append the 5 neighboring elements so that I have: int b[]={20101,10211,10101}; I need to do this for various length arrays, in most cases with length of a being greater than 15.

Any help would be greatly appreciated, I'm programming in Java.

Thanks in advance.

• Etaoin: Integer concatenation doesn't necessarily make sense -- for example, have you considered what behavior you'd like to define if the integers are negative?
• Thomas Lötzer: What do you want to happen when the first element of each 5-int-block is a 0? Should the result of 0,1,2,3,4 be 01234 or 1234?
• ms87: I need it to be 01234, since I'm using this for encoding messages, I need to keep all 5 digits.
• polygenelubricants: See also: stackoverflow.com/questions/2674707/…

Answer 1

It's pretty straighforward:

// Assuming a.length % 5 == 0.
int[] b = new int[a.length / 5];
for (int i = 0; i < a.length; i += 5) {
 b[i/5] = a[i]*10000 + a[i+1]*1000 + a[i+2]*100 + a[i+3]*10 + a[i+4];
}

• Finbarr: If a.length does not divide evenly by 5 the array will not be big enough, and various exceptions will be thrown inside the for loop.
• ms87: Thansk, that works fine, but when I'm dealing with integers starting with 0, with the above method I lose the 0, for example: a={0,2,2,2,2,1,0,2,0,2}; I get b={2222,10202}; instead of b={02222,10202}; which is what i need. Any way to stop that happening?
• ms87: @Finbarr, the length of a will always be divisible by 5, so thankfully that won't be a problem.
• Syntactic: If you want to keep the leading zeroes, you cannot store these as integers. Use Strings instead.
• Jesper: If you need to keep the leading zeroes, then b cannot be an int[], because numbers can't have leading zeroes. You could make it for example a String[].

Answer 2

This sounds like a homework question, so I won't give you the complete solution, but the basic rundown is:

1. Compute the length of b: len = a.length / 5
2. Construct b with that many elements.
3. Initialize an index variable to point to the first element in a
4. For each element in b:
   • Construct the value for that element from a[idx]...a[idx+4]
   • Advance the index into a by 5.

Also note that you may need to verify that the input a is actually a multiple of 5 in length.

Answer 3

This works with (a.length % 5) != 0, and keeps leading zeroes (by storing digits into String).

 int a[]={2,0,1,0,1,1,0,2,1,1,1,0,1,0,1,0,0,7};
 final int N = 5;
 String b[] = new String[(a.length + N - 1)/ N];
 StringBuilder sb = new StringBuilder(N);
 int x = 0;
 for (int i = 0; i < b.length; i++) {
 sb.setLength(0);
 for (int k = 0; k < N && x < a.length; k++) {
 sb.append(a[x++]);
 }
 b[i] = sb.toString();
 }
 System.out.println(java.util.Arrays.toString(b));
 // prints "[20101, 10211, 10101, 007]"

---

Alternately, you can also use regex:

 String[] arr =
 java.util.Arrays.toString(a)
 .replaceAll("\\D", "")
 .split("(?<=\\G.{5})");
 System.out.println(java.util.Arrays.toString(arr));
 // prints "[20101, 10211, 10101, 007]"

Basically this uses Arrays.toString(int[]) to append all digits into one long String, then removes all non-digits \D, then uses \G-anchored lookbehind to split every .{5}

Answer 4

Naive approach.

import java.util.ArrayList;
/* Naive approach */
public class j2728476 {
 public static void main(String[] args) {
 int a[] = {2,0,1,0,1,1,0,2,1,1,1,0,1,0,1};
 ArrayList<String> al = new ArrayList<String>();
 String s = "";
 for (int i = 0; i < a.length; i++) {
 if (i % 5 == 0 && i != 0) {
 al.add(s);
 s = "" + a[i];
 } else {
 s += a[i];
 }
 }
 al.add(s);
 for (String t : al) {
 // convert values to ints ...
 System.out.println(t);
 }
 }
}

Will print:

20101
10211
10101

Answer 5

import java.util.Arrays;
public class MainClass {
 public static void main(String args[]) throws Exception {
 int array[] = { 2, 5, -2, 6, -3, 8, 0, -7, -9, 4 };
 Arrays.sort(array);
 printArray("Sorted array", array);
 int index = Arrays.binarySearch(array, 1);
 System.out.println("Didn't find 1 @ "
 + index);
 int newIndex = -index - 1;
 array = insertElement(array, 1, newIndex);
 printArray("With 1 added", array);
 }
 private static void printArray(String message, int array[]) {
 System.out.println(message
 + ": [length: " + array.length + "]");
 for (int i = 0; i < array.length; i++) {
 if (i != 0){
 System.out.print(", ");
 }
 System.out.print(array[i]); 
 }
 System.out.println();
 }
 private static int[] insertElement(int original[],
 int element, int index) {
 int length = original.length;
 int destination[] = new int[length + 1];
 System.arraycopy(original, 0, destination, 0, index);
 destination[index] = element;
 System.arraycopy(original, index, destination, index
 + 1, length - index);
 return destination;
 }
}

It will print

Sorted array: [length: 10]
-9, -7, -3, -2, 0, 2, 4, 5, 6, 8
Didn't find 1 @ -6
With 1 added: [length: 11]
-9, -7, -3, -2, 0, 1, 2, 4, 5, 6, 8