# Monthly Archives: May 2014

# Array Fun 2 [Java]

**public int[] digitsToArray(int nums)**

Description:This method creates an array that is filled with all of the digits of`nums`

.

Method Call |
return value/output |

digitsToArray( 523 ) | {5,2,3} |

digitsToArray(1267 ) | { 1 , 2 , 6 , 7} |

**public boolean allFactorsOfSum(int[] nums)**

Description:This method returns true if each element of`nums`

is a factor of the sum of`nums`

.

Method Call |
return value/output |

allFactorsOfSum( {6,1,2,3} ) | true (because all of the elements are factors of the sum which is12) |

allFactorsOfSum( {1,4,7 }) | false (because 7 is not a factor of the sum of this array which is 12) |

**public String[] doubleArr(String[] strs)**

Description:This method returns a new version of`strs`

with each element appearing twice.

Method Call |
return value/output |

doubleArr( {“a”,”b”,”c”} ) | {“a”,”a”,”b”,”b”, “c” , “c”} |

doubleArr( {“math”,”ware”,”house”,”.com” }) | {“math”,”math”,”ware”,”ware”,”house”,”house”,”.com”, “.com”} |

**public boolean isThere(int[] nums, int num)**

Description:This method returns true if`num`

is an element`nums`

.

Method Call |
return value/output |

isThere( {6,1,2,3}, 6) | true |

isThere( {6,1,2,3}, 5 ) | false |

**public int indexOf5(int[] nums )**

Description:This returns the index of the first occurrence element ‘5’ or -1 if 5 does not exist.

Method Call |
return value/output |

indexOf5( { 2 , 3 , 5 , 4 } ) |
2 |

indexOf5( { 2 , 3 , 5 , 4, 5 } ) |
2 |

indexOf5( { 2 , 3 ,7 , 4, 3, } ) | -1 |

**public int indexOf(int[] nums, int num)**

Description:This method returns the index value of the first appearance of`num`

or -1 if`num`

is not an element of`nums`

.

Method Call |
return value/output |

indexOf( {6,4 ,7,3, 4 }, 4) |
1 |

indexOf( {6,4 7 ,3,2,7}, 7) |
2 |

indexOf( {6,4 ,2,3}, 22) | -1 |

**public int lastIndexOf(int[] nums, int num)**

Description:This method returns the index value of the last appearance of`num`

or -1 if`num`

is not an element of`nums`

.

Method Call |
return value/output |

lastIndexOf( {6, 4 ,7 ,3, 11, ,4}, 4) |
5 |

lastIndexOf( {7, 6,4 , 7 ,3}, 7) |
3 |

lastIndexOf( {6,4 ,2,3}, 22) | -1 |

**public boolean isIncreasing(double[] nums)**

Description:This method returns true if each element in nums is greater than the element to its left.

Method Call |
return value/output |

isIncreasing( {1,2,3,4 }) | true |

isIncreasing( {1,0 ,3,4 }) |
false |

isIncreasing( {1,1, 2,3,4 }) |
false |

isIncreasing( {-1, –1, -2, -3, -4 }) |
false |

*** public int largestSpan(int[] nums)**

Description:This method returns the largest span of consecutive increasing numbers

Method Call |
return value/output |

largestSpan( {4, 3, 1, 3, 6 , 1} ) |
3 |

largestSpan( {4 3 1 , 12 , 31 , 44 , 52 , 1} ) |
5 |

largestSpan( {1 , 7 8 , 12,4, 3, 0, 4 , 1) |
3 |

**int[] invert(int[] nums)**

Description:This method ‘inverts’ an array by spliting the array in halves and ‘inverting’ each half. See sample calls to understand.

Method Call |
return value/output |

invert( {5 , 21, 5, 13,4 }) | {21 , 5 , 5, 4,13 } |

**int[] shiftByN(int[] nums, int delta)**

Description:This method returns the array with all digits shifted by`delta`

. Any digits that are circulated off the end of the array should be returned to the other side. Note: delta could be positive or negative. Please keep in mind that Math.abs(delta) > nums.length could be possible 😉

Method Call |
return value/output |

shiftByN( {5 , 21, 13,4 } 1) | { 4 , 5 , 21, 13 } |

shiftByN( {5 , 21, 13, 4 , 11} 2) | { 4 , 11 , 5 , 21, 13} |

shiftByN( {5 , 21, 13, 4 } -1) | { 21, 13, 4 , 5} |

shiftByN( {5 , 21, 13, 4 ,7 } -2) | { 13, 4 ,7 , 5 , 21} |

**int[] add(int[] num1, int[] num2, int base) throws ArithmeticException**

**@precondition**

`1 < base < 11`

**@precondition**

**num1**.length = 5 and **num2.length = 5**

**@postcondition:**the returned array has 5 elements representing the sum or an ArithmeticException is thrown

Description:This method attempts to replicate addition. Consider both num1 and num2 represent the five digits of a number. Each element in the array stores one of the digits. For instance, the number 143 would be represented as {0,0,1,4,3 }. Numbers can be in any base between 2 and 10 inclusive , and the number 10110_{2}in binary would appear in an arrays as : {1, 0, 1 , 1, 0 } . Let’s assume the numbers are positive.You should return an array representing the digits of the sum of num1 and num2.Ifthe number of digits in thesum exceeds the maximum number of digits (5) , you should throw an arithmetic exception as shown in the code below:

12 if(overFlowAdditionOccurred)throw new ArithmeticException("Addition Overflow Error");

**Note:** You may not use any kind of helper or utility methods that are built into pre-defined Java classes for converting numbers between bases. Only use techniques taught in this class.

Method Call |
return value/output |

add( {0,0,0 ,4,2},{0,0,0,5,1}, 10) | {0, 0, 0, 9, 3} ie (42 + 51 = 93) |

add( {0, 0, 0 ,7,2},{0,0,0,5,1}, 10) | {0, 0 , 1 , 2, 3} ie (72 + 51 = 123) |

add( {0, 0 , 0 , 1 , 1}, { 0 , 0 , 0 , 1 }, 2) | {0, 0 , 1 , 0 , 0} ie ( 11_{2} + 1_{2}= 100_{2} ) |