Salesforce Interview Question
SDETsCountry: United States
public class ReverseByGroupSize {
public static void main(String[] args) {
Integer[] arr = {1,2,3,4,5};
int grpSize = 1;
Arrays.sort(arr);
List<Integer> list = Arrays.asList(arr);
List<Integer> subList = new ArrayList<Integer>();
List<Integer> finalList = new ArrayList<Integer>();
double temp = Math.ceil(arr.length/(double)grpSize);
for(int i=0; i < temp; i++){
if((i+1)*grpSize <= arr.length-1)
subList = list.subList(i*grpSize, (i+1)*grpSize);
else
subList = list.subList(i*grpSize, arr.length);
Collections.reverse(subList);
finalList.addAll(subList);
}
System.out.println(finalList);
}
}
public class ReverseByGroupSize {
public static void main(String[] args) {
Integer[] arr = {1,2,3,4,5};
int grpSize = 1;
Arrays.sort(arr);
List<Integer> list = Arrays.asList(arr);
List<Integer> subList = new ArrayList<Integer>();
List<Integer> finalList = new ArrayList<Integer>();
double temp = Math.ceil(arr.length/(double)grpSize);
for(int i=0; i < temp; i++){
if((i+1)*grpSize <= arr.length-1)
subList = list.subList(i*grpSize, (i+1)*grpSize);
else
subList = list.subList(i*grpSize, arr.length);
Collections.reverse(subList);
finalList.addAll(subList);
}
System.out.println(finalList);
}
}
public class ReverseByGroupSize {
public static void main(String[] args) {
Integer[] arr = {1,2,3,4,5};
int grpSize = 1;
Arrays.sort(arr);
List<Integer> list = Arrays.asList(arr);
List<Integer> subList = new ArrayList<Integer>();
List<Integer> finalList = new ArrayList<Integer>();
double temp = Math.ceil(arr.length/(double)grpSize);
for(int i=0; i < temp; i++){
if((i+1)*grpSize <= arr.length-1)
subList = list.subList(i*grpSize, (i+1)*grpSize);
else
subList = list.subList(i*grpSize, arr.length);
Collections.reverse(subList);
finalList.addAll(subList);
}
System.out.println(finalList);
}
}
public class ReverseByGroupSize {
public static void main(String[] args) {
Integer[] arr = {1,2,3,4,5};
int grpSize = 1;
Arrays.sort(arr);
List<Integer> list = Arrays.asList(arr);
List<Integer> subList = new ArrayList<Integer>();
List<Integer> finalList = new ArrayList<Integer>();
double temp = Math.ceil(arr.length/(double)grpSize);
for(int i=0; i < temp; i++){
if((i+1)*grpSize <= arr.length-1)
subList = list.subList(i*grpSize, (i+1)*grpSize);
else
subList = list.subList(i*grpSize, arr.length);
Collections.reverse(subList);
finalList.addAll(subList);
}
System.out.println(finalList);
}
}
public void reverseByGroup (int [] array, int k){
if ( array == null || array.length == 0 || k > array.length) {
return ;
}
int i = 0 , tail = 0;
int c = 1 ;
while ( i < array.length) {
if (c % k == 0){
reverse (array, tail ,i) ;
tail = i + 1 ;
}
i++;
c++;
}
}
private void reverse (int [] array, int i , int j){
for (; i < j ; ++i, --j) {
swap (array, i, j);
}
}
private void swap (int [] array , int i , int j){
int tmp = array[i] ;
array[i] = array[j] ;
array[j] = tmp ;
}
void Main()
{
int[] x = {1,2,3,4,5,6,7,8};
int index = 3;
x.Dump();
for( var i = 0; i < x.Length; i= i+index)
{
reversearrayelements(x, i, index);
}
x.Dump();
}
public void reversearrayelements(int[] y, int startindex, int elementsinarray)
{
int finalindex = (y.Length < startindex + elementsinarray ? y.Length : startindex + elementsinarray) -1;
while(startindex < finalindex)
{
y[startindex] = y[startindex] + y[finalindex];
y[finalindex] = y[startindex] - y[finalindex];
y[startindex] = y[startindex++] - y[finalindex--];
}
}
void Main()
{
int[] x = {1,2,3,4,5,6,7,8};
int index = 3;
x.Dump();
for( var i = 0; i < x.Length; i= i+index)
{
reversearrayelements(x, i, index);
}
x.Dump();
}
public void reversearrayelements(int[] y, int startindex, int elementsinarray)
{
int finalindex = (y.Length < startindex + elementsinarray ? y.Length : startindex + elementsinarray) -1;
while(startindex < finalindex)
{
y[startindex] = y[startindex] + y[finalindex];
y[finalindex] = y[startindex] - y[finalindex];
y[startindex] = y[startindex++] - y[finalindex--];
}
}
void Main()
{
int[] x = {1,2,3,4,5,6,7,8};
int index = 3;
x.Dump();
for( var i = 0; i < x.Length; i= i+index)
{
reversearrayelements(x, i, index);
}
x.Dump();
}
public void reversearrayelements(int[] y, int startindex, int elementsinarray)
{
int finalindex = (y.Length < startindex + elementsinarray ? y.Length : startindex + elementsinarray) -1;
while(startindex < finalindex)
{
y[startindex] = y[startindex] + y[finalindex];
y[finalindex] = y[startindex] - y[finalindex];
y[startindex] = y[startindex++] - y[finalindex--];
}
}
Question was little unclear as what it should return if group size is greater than array size. Considering that as invalid entry below is code:
import java.util.Arrays;
class ReverseArrayByGroupSize {
public void solution(int[] arr, int num) {
if (num > arr.length || num == 0) {
System.out.println("Invalid Entry");
return;
}
int start = 0;
int last = 0;
int end = arr.length / num;
for (int i = 0; i < end; i++) {
start = i * num;
last = (i + 1) * num - 1;
int x = ((last - start) / 2) + start;
int k = last;
for (int j = start; j <= x; j++) {
int temp = arr[j];
arr[j] = arr[k];
arr[k] = temp;
k--;
}
}
if (last != arr.length - 1) {
start = last + 1;
last = arr.length - 1;
while (start <= last) {
int temp = arr[start];
arr[start++] = arr[last];
arr[last--] = temp;
}
}
System.out.println(Arrays.toString(arr));
}
}
public class SalesforceReverseArrayByGroupSize {
public static void main(String[] args) {
ReverseArrayByGroupSize mSol = new ReverseArrayByGroupSize();
mSol.solution(new int[] {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
}, 3);
mSol.solution(new int[] {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13
}, 4);
mSol.solution(new int[] {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
}, 4);
mSol.solution(new int[] {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
}, 6);
mSol.solution(new int[] {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
}, 15);
mSol.solution(new int[] {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
}, 16);
mSol.solution(new int[] {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
}, 17);
}
}
# Cmdline Input:
# prog N val1 val2 ... valN
nums = ARGV.map { |v| v.to_i }
gsize = nums.shift.to_i
res = nums.inject([]) do |ary, val|
ary.unshift val
if ary.size % gsize == 0
ary = ary.rotate gsize
end
if ary.size == nums.size
rot_by = ary.size % gsize
# Perform final rotation
ary = ary.rotate rot_by
end
ary
end
puts "result: #{res}"
#! /usr/bin/ruby
nums = ARGV.map { |v| v.to_i }
gsize = nums.shift.to_i
res = nums.inject([]) do |ary, val|
ary.unshift val
if ary.size % gsize == 0
ary = ary.rotate gsize
end
if ary.size == nums.size
rot_by = ary.size % gsize
# Perform final rotation
ary = ary.rotate rot_by
end
ary
end
puts "result: #{res}"
public class GroupSize {
public static void main(String[] args) {
int[] arr3 = { 1, 2, 3, 4, 5, 6, 7, 8 };
// taking group size 3
printInGroupSize(arr3, 3);
for (int ele : arr3) {
System.out.println(ele);
}
}
public static void printInGroupSize(int[] arr, int gsize) {
if (arr == null || arr.length == 0 || gsize == 0 || gsize == 1) {
return;
}
int d = arr.length / gsize;
int rem = arr.length % gsize;
int start = 0;
int end = gsize - 1;
for (int i = 0; i < d; i++) {
reverse(arr, start, end);
start += gsize;
end += gsize;
}
// handling remainder
reverse(arr, start, end + rem - gsize);
}
public static void reverse(int[] arr, int start, int end) {
if (start != end && start <= end) {
swap(arr, start, end);
reverse(arr, start + 1, end - 1);
}
}
public static void swap(int[] arr, int i, int j) {
arr[i] = arr[i] + arr[j];
arr[j] = arr[i] - arr[j];
arr[i] = arr[i] - arr[j];
}
}
public class ReverseGroupSize {
public static void main(String[] args) {
int[] arr3 = { 1, 2, 3, 4, 5, 6, 7, 8 };
// taking group size 3
doReverseInGroupSize(arr3, 3);
for (int ele : arr3) {
System.out.println(ele);
}
}
public static void doReverseInGroupSize(int[] arr, int gsize) {
if (arr == null || arr.length == 0 || gsize == 0 || gsize == 1) {
return;
}
int d = arr.length / gsize;
int rem = arr.length % gsize;
int start = 0;
int end = gsize - 1;
for (int i = 0; i < d; i++) {
reverse(arr, start, end);
start += gsize;
end += gsize;
}
// handling remainder
reverse(arr, start, end + rem - gsize);
}
public static void reverse(int[] arr, int start, int end) {
if (start != end && start <= end) {
swap(arr, start, end);
reverse(arr, start + 1, end - 1);
}
}
public static void swap(int[] arr, int i, int j) {
arr[i] = arr[i] + arr[j];
arr[j] = arr[i] - arr[j];
arr[i] = arr[i] - arr[j];
}
}
static int[] reverseGroup(int[] arr, int g) {
int N = arr.length;
int repeatLength = (N / g) * g;
for (int i = 0; i < repeatLength; i += g) {
reverse(arr, i, g);
}
if (N - repeatLength > 0) {
reverse(arr, repeatLength, N - repeatLength);
}
return arr;
}
private static void reverse(int[] arr, int start, int len) {
for (int i = 0; i < len / 2; i++) {
swap(arr, start + i, start + len - i - 1);
}
}
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
1. For given group size take two var min and max index
2. reverse array elements between min and max by swapping from the end
3. Increase min and max by group size and repeat step 2 till we reach the end
Check for boundary condition when actual size will be less then group size if array size is not multiplier of the group size
Iterate over array finding start/end indexes for each group then swap elements in group to reverse.
function reverseArray(arr, groupSize) {
var i = 0;
while (i < arr.length) {
var start = i;
var end = Math.min(i + groupSize - 1, arr.length - 1);
while (start < end) {
swap(arr, start, end);
start++;
end--;
}
i += groupSize;
}
return arr;
}
function swap(arr, a, b) {
var tmp = arr[a];
arr[a] = arr[b];
arr[b] = tmp;
}
private static void reverseSection(int[] arr, int start, int end){
int temp;
while(start < end){
temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}
public static void reverseSections(int[] arr, int sectionSize){
if(arr == null){
throw new NullPointerException("\"arr\" may not be null");
}
if(sectionSize < 1){
throw new IllegalArgumentException("\"sectionSize\" must be greater than 0");
}
int index = 0;
while(index < arr.length - sectionSize){
reverseSection(arr, index, index+sectionSize -1);
index += sectionSize;
}
if(index < arr.length - 1){
reverseSection(arr, index, arr.length -1);
}
}
and testing with JUnit
@Test(expected=NullPointerException)
public void test_reverseSections_arg1_null(){
reverseSections(null, -1);
}
@Test(expected=IllegalArgumentException)
public void test_reverseSections_arg2_illegal(){
reverseSections(new int[]{1, 2, 3}, -1
}
@Test
public void test_reverseSections_arg1_empty(){
//just verifying that there are no exceptions
reverseSections(new int[]{}, 3);
}
@Test
public void test_reverseSections_arg1_1int(){
int[] vals = new int[]{ 1 };
reverseSections(vals, 1);
assertTrue(vals[0] == 1);
vals[0] = 7;
reverseSections(vals, 13);
assertTrue(vals[0] == 7);
}
@Test
public void test_reverseSections_arg1_5int(){
assertReverseSections(new int[]{1, 2, 3, 4, 5}, 1, new int[]{1, 2, 3, 4, 5});
assertReverseSections(new int[]{1, 2, 3, 4, 5}, 2, new int[]{2, 1, 4, 3, 5});
assertReverseSections(new int[]{1, 2, 3, 4, 5}, 3, new int[]{3, 2, 1, 5, 4});
assertReverseSections(new int[]{1, 2, 3, 4, 5}, 4, new int[]{4, 3, 2, 1, 5});
assertReverseSections(new int[]{1, 2, 3, 4, 5}, 5, new int[]{5, 4, 3, 2, 1});
assertReverseSections(new int[]{1, 2, 3, 4, 5}, 6, new int[]{5, 4, 3, 2, 1});
assertReverseSections(new int[]{1, 2, 3, 4, 5}, 13, new int[]{5, 4, 3, 2, 1});
}
private void assertReverseSections(int[] arr, int size, int[] expected){
reverseSections(arr, size);
assertTrue(Arrays.equal(arr, expected));
}
def reverse_grp(alist, size) :
k=0
a = len(alist)
num = a/size
for i in range(num+1):
if i == 0 :
alist[i*size : i*size +size ] = alist[i*size +size - 1: :-1]
else:
alist[i*size : i*size +size ] = alist[i*size +size - 1: i*size -1 :-1]
return alist
print reverse_grp([1,2,3,4,5,6,7,8,9], 3)
{def reverse_grp(alist, size) :
k=0
a = len(alist)
num = a/size
for i in range(num+1):
if i == 0 :
alist[i*size : i*size +size ] = alist[i*size +size - 1: :-1]
else:
alist[i*size : i*size +size ] = alist[i*size +size - 1: i*size -1 :-1]
return alist
print reverse_grp([1,2,3,4,5,6,7,8,9], 3)}
def reverse_grp(alist, size) :
k=0
a = len(alist)
num = a/size
for i in range(num+1):
if i == 0 :
alist[i*size : i*size +size ] = alist[i*size +size - 1: :-1]
else:
alist[i*size : i*size +size ] = alist[i*size +size - 1: i*size -1 :-1]
return alist
print reverse_grp([1,2,3,4,5,6,7,8,9], 3)
public static int[] reverseArray(int[] arr, int grp){
int istart =0;
if(arr.length%grp!=0){
reverse(arr,arr.length-arr.length%grp, arr.length);
}
for(int i=grp;i<=arr.length;i+=grp){
reverse(arr, istart, i);
istart+=grp;
}
return arr;
}
public static void reverse(int[]arr, int istart, int iend){
int temp=0;
iend=iend-1;
for(int i=istart;i<iend;i++){
temp = arr[iend];
arr[iend]=arr[i];
arr[i]=temp;
iend--;
if(istart==iend){
break;
}
}
}
public static int[] reverseArray(int[] arr, int grp){
int istart =0;
if(arr.length%grp!=0){
reverse(arr,arr.length-arr.length%grp, arr.length);
}
for(int i=grp;i<=arr.length;i+=grp){
reverse(arr, istart, i);
istart+=grp;
}
return arr;
}
public static void reverse(int[]arr, int istart, int iend){
int temp=0;
iend=iend-1;
for(int i=istart;i<iend;i++){
temp = arr[iend];
arr[iend]=arr[i];
arr[i]=temp;
iend--;
if(istart==iend){
break;
}
}
}
def rev_by_grp_size(lst, n):
if not lst:
return []
r_lst = []
reversed_grp = 0
stack = []
for i, item in enumerate(lst):
stack.append(item)
if (i + 1) % n == 0:
reversed_grp += 1
while len(stack) != 0:
r_lst.append(stack.pop())
if reversed_grp != n:
while len(stack) != 0:
r_lst.append(stack.pop())
return r_lst
def rev_by_grp_size(lst, n):
if not lst:
return []
r_lst = []
reversed_grp = 0
stack = []
for i, item in enumerate(lst):
stack.append(item)
if (i + 1) % n == 0:
reversed_grp += 1
while len(stack) != 0:
r_lst.append(stack.pop())
if reversed_grp != n:
while len(stack) != 0:
r_lst.append(stack.pop())
return r_lst
def rev_by_grp_size(lst, n):
if not lst:
return []
r_lst = []
reversed_grp = 0
stack = []
for i, item in enumerate(lst):
stack.append(item)
if (i + 1) % n == 0:
reversed_grp += 1
while len(stack) != 0:
r_lst.append(stack.pop())
if reversed_grp != n:
while len(stack) != 0:
r_lst.append(stack.pop())
return r_lst
package Arrays;
import java.util.Stack;
/**
*
**
**
**
**
**
** Given a array of integer and group size, reverse array by group size, example
* as follows: [1, 2, 3, 4, 5, 6], 1 -> [1, 2, 3, 4, 5, 6] [1, 2, 3, 4, 5, 6], 2
* -> [2, 1, 4, 3, 6, 5] [1, 2, 3, 4, 5, 6], 3 -> [3, 2, 1, 6, 5, 4] [1, 2, 3,
* 4, 5, 6, 7, 8], 3 -> [3, 2, 1, 6, 5, 4, 8, 7] Design test cases for you API
**
**
**
*/
public class ReverseByGroup {
public static void main(String[] Args) {
// Test Cases
int[] arr1 = { 1, 2, 3, 4, 5, 6 };
int groupSize = 1;
arr1 = reverseGroupWise(arr1, groupSize);
printArray(arr1);
System.out.println();
int[] arr2 = { 1, 2, 3, 4, 5, 6 };
groupSize = 3;
arr2 = reverseGroupWise(arr2, groupSize);
printArray(arr2);
System.out.println();
int[] arr3 = { 1, 2, 3, 4, 5, 6 };
groupSize = 4;
arr3 = reverseGroupWise(arr3, groupSize);
printArray(arr3);
System.out.println();
int[] arr4 = { 1, 2, 3, 4, 5, 6 };
groupSize = 6;
arr4 = reverseGroupWise(arr4, groupSize);
printArray(arr4);
System.out.println();
int[] arr5 = { 1, 2, 3, 4, 5, 6 };
groupSize = 8;
arr5 = reverseGroupWise(arr5, groupSize);
printArray(arr5);
System.out.println();
}
public static void printArray(int[] a) {
for (int i = 0; i < a.length; i++) {
System.out.print(">>" + a[i]);
}
}
public static int[] reverseGroupWise(int[] arr, int groupSize) {
if (arr == null || arr.length == 0) {
System.out.println(" wrong input");
return null;
}
if (groupSize < 1) {
System.out.println("group Size is less than 1");
return null;
}
for (int i = 0; i < arr.length;) {
int lower = i;
int upper = lower + groupSize - 1;
reverseInRange(arr, lower, upper);
i = i + groupSize;
}
return arr;
}
public static void reverseInRange(int[] arr, int l, int u) {
Stack<Integer> myStack = new Stack<>();
// filling stack
for (int i = l; i <= u && i < arr.length; i++) {
myStack.push(arr[i]);
}
// emptying stack
for (int i = l; i <= u && i < arr.length; i++) {
arr[i] = myStack.pop();
}
return;
}
}
package Arrays;
import java.util.Stack;
/**
*
**
**
**
**
**
** Given a array of integer and group size, reverse array by group size, example
* as follows: [1, 2, 3, 4, 5, 6], 1 -> [1, 2, 3, 4, 5, 6] [1, 2, 3, 4, 5, 6], 2
* -> [2, 1, 4, 3, 6, 5] [1, 2, 3, 4, 5, 6], 3 -> [3, 2, 1, 6, 5, 4] [1, 2, 3,
* 4, 5, 6, 7, 8], 3 -> [3, 2, 1, 6, 5, 4, 8, 7] Design test cases for you API
**
**
**
*/
public class ReverseByGroup {
public static void main(String[] Args) {
// Test Cases
int[] arr1 = { 1, 2, 3, 4, 5, 6 };
int groupSize = 1;
arr1 = reverseGroupWise(arr1, groupSize);
printArray(arr1);
System.out.println();
}
public static void printArray(int[] a) {
for (int i = 0; i < a.length; i++) {
System.out.print(">>" + a[i]);
}
}
public static int[] reverseGroupWise(int[] arr, int groupSize) {
if (arr == null || arr.length == 0) {
System.out.println(" wrong input");
return null;
}
if (groupSize < 1) {
System.out.println("group Size is less than 1");
return null;
}
for (int i = 0; i < arr.length;) {
int lower = i;
int upper = lower + groupSize - 1;
reverseInRange(arr, lower, upper);
i = i + groupSize;
}
return arr;
}
public static void reverseInRange(int[] arr, int l, int u) {
Stack<Integer> myStack = new Stack<>();
// filling stack
for (int i = l; i <= u && i < arr.length; i++) {
myStack.push(arr[i]);
}
// emptying stack
for (int i = l; i <= u && i < arr.length; i++) {
arr[i] = myStack.pop();
}
return;
}
}
public class ReverseByGroupSize {
private static void reverseBet(int[] arr, int start, int end){
int temp=0;
while(start<end){
temp =arr[start];
arr[start]=arr[end];
arr[end] = temp;
start++;
end--;
}
}
public static void reverseArrayK(int[] arr, int k){
int i=0;
for(i=0;i+k<=arr.length;i+=k){
reverseBet(arr,i,i+k-1);
}
if(i+k>arr.length){
reverseBet(arr,i,arr.length-1);
}
return;
}
public static void main(String args[]){
int[] nums = {1,2,3,4,5,6,7,8};
reverseArrayK(nums,6);
System.out.println(Arrays.toString(nums));
}
}
public class ReverseByGroupSize {
private static void reverseBet(int[] arr, int start, int end){
int temp=0;
while(start<end){
temp =arr[start];
arr[start]=arr[end];
arr[end] = temp;
start++;
end--;
}
}
public static void reverseArrayK(int[] arr, int k){
int i=0;
for(i=0;i+k<=arr.length;i+=k){
reverseBet(arr,i,i+k-1);
}
if(i+k>arr.length){
reverseBet(arr,i,arr.length-1);
}
return;
}
public static void main(String args[]){
int[] nums = {1,2,3,4,5,6,7,8};
reverseArrayK(nums,6);
System.out.println(Arrays.toString(nums));
}
}
public class ReverseByGroupSize {
private static void reverseBet(int[] arr, int start, int end){
int temp=0;
while(start<end){
temp =arr[start];
arr[start]=arr[end];
arr[end] = temp;
start++;
end--;
}
}
public static void reverseArrayK(int[] arr, int k){
int i=0;
for(i=0;i+k<=arr.length;i+=k){
reverseBet(arr,i,i+k-1);
}
if(i+k>arr.length){
reverseBet(arr,i,arr.length-1);
}
return;
}
public static void main(String args[]){
int[] nums = {1,2,3,4,5,6,7,8};
reverseArrayK(nums,6);
System.out.println(Arrays.toString(nums));
}
}
import java.util.Random;
public class ArrangeArrayElements {
private static int[] a = new int[18];
private static void rearrangeElements(int grpSize) {
if (grpSize == 1)
return;
int j = 0;
for (; j < a.length; j = j + grpSize) {
int k = (j + grpSize);
for (int n = j; n < (j + (grpSize / 2)) && k < a.length; n++) {
int temp = a[n];
a[n] = a[--k];
a[k] = temp;
}
}
if (j > a.length) {
int remainingElements = a.length - (j - grpSize);
int arrLen = a.length;
for (int n = arrLen - remainingElements; n < (n + remainingElements / 2) && n < (a.length - 1); n++) {
int temp = a[n];
a[n] = a[--arrLen];
a[arrLen] = temp;
}
}
}
public static void main(String[] args) {
Random rnd = new Random();
for (int i = 0; i < 18; i++) {
a[i] = rnd.nextInt(100);
;
System.out.print(a[i] + ",");
}
rearrangeElements(3);
System.out.println();
for (int i = 0; i < 18; i++)
System.out.print(a[i] + ",");
}
}
My python code
def groupReverse(list, size):
if size == 1: return list
n = len(list) / size
for i in range(n + 1):
list = list[:i * size] + list[i*size:(i+1)*size][::-1] + list[(i+1)*size:]
return list
print groupReverse([1,2,3,4,5,6], 1)
print groupReverse([1,2,3,4,5,6], 2)
print groupReverse([1,2,3,4,5,6], 3)
print groupReverse([1,2,3,4,5,6,7,8], 3)
int[] kGroupReverse(int[] nums, int k) {
if (nums == null || nums.length == 0 || k == 1) { return nums; }
for (int i = 0; i < nums.length; i = i + k) {
reverse(nums, i, i + k);
}
return nums;
}
void reverse(int[] nums, int left, int right) {
while (left < right) {
int temp = nums[left];
nums[left++] = nums[--right];
nums[right] = temp;
}
}
package com.sikar.array.problems;
public class ReverseArrayByGroupSize {
/**
* Given a array of integer and group size, reverse array by group size, example as follows:
[1, 2, 3, 4, 5, 6], 1 -> [1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6], 2 -> [2, 1, 4, 3, 6, 5]
[1, 2, 3, 4, 5, 6], 3 -> [3, 2, 1, 6, 5, 4]
[1, 2, 3, 4, 5, 6, 7, 8], 3 -> [3, 2, 1, 6, 5, 4, 8, 7]
Design test cases for you API
*/
public void reverseArrayByGroupSize(int[] a, int groupSize){
if(groupSize < 2){
return;
}
int end = groupSize-1;
for(int i=0;i<a.length;){
reverseArray(a, i, end);
i = i+groupSize;
end = end+groupSize;
}
if(a.length%groupSize != 0){
int rem = a.length%groupSize;
reverseArray(a, a.length-rem, a.length-1);
}
}
public void reverseArray(int[] a,int start,int end){
if(start >=0 && end < a.length){
for(int i=start;i<=end;i++,end--){
swap(a,i,end);
}
}
}
public void swap(int[] a, int indexOne,int indexTwo){
int temp = a[indexOne];
a[indexOne] = a[indexTwo];
a[indexTwo] = temp;
}
public void print(int[] a){
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
}
public static void main(String args[]){
ReverseArrayByGroupSize tool = new ReverseArrayByGroupSize();
int a[] = {1, 2, 3, 4, 5, 6};
tool.reverseArrayByGroupSize(a, 4);
tool.print(a);
}
}
def reverse_list(inp_list, cnt):
idx, count = 0,0
return_list = []
l = len(inp_list)
split_list = [inp_list[i:i+cnt] for i in range(0,l,cnt)]
print split_list
b = [i[::-1] for i in split_list]
print b
for j in b:
return_list.extend(j)
return return_list
assert reverse_list([1, 2, 3, 4, 5, 6], 1) == [1, 2, 3, 4, 5, 6]
Python solution
def reverse_list(inp_list, cnt):
idx, count = 0,0
return_list = []
l = len(inp_list)
split_list = [inp_list[i:i+cnt] for i in range(0,l,cnt)]
print split_list
b = [i[::-1] for i in split_list]
print b
for j in b:
return_list.extend(j)
return return_list
assert reverse_list([1, 2, 3, 4, 5, 6], 1) == [1, 2, 3, 4, 5, 6]
C# Solution
public static int[] ReverseByGroupSize(int[] input, int groupSize)
{
if (input == null)
{
return null;
}
if (groupSize == 1)
{
return input;
}
var length = 0;
while (length < input.Length)
{
var startIndex = length;
var endIndex = Math.Min(length + groupSize, input.Length);
while (startIndex < endIndex - 1)
{
var x = input[startIndex];
var y = input[endIndex - 1];
input[endIndex - 1] = x;
input[startIndex] = y;
endIndex--;
startIndex++;
}
length += groupSize;
}
return input;
}
C# Solution with in place reverse.
public static int[] ReverseByGroupSize(int[] input, int groupSize)
{
if (input == null)
{
return null;
}
if (groupSize == 1)
{
return input;
}
var length = 0;
while (length < input.Length)
{
var startIndex = length;
var endIndex = Math.Min(length + groupSize, input.Length);
while (startIndex < endIndex - 1)
{
input[startIndex] = input[startIndex] + input[endIndex - 1];
input[endIndex - 1] = input[startIndex] - input[endIndex - 1];
input[startIndex] = input[startIndex] - input[endIndex - 1];
endIndex--;
startIndex++;
}
length += groupSize;
}
return input;
}
public static void main(String[] args) {
int[] array = new int[] { 1, 2, 3, 4, 5, 6, 7 };
int index = 3;
int[] newArray = Arrays.copyOf(array, index);
List<Integer> list = Ints.asList(newArray);
Collections.reverse(list);
int len = array.length;
Integer[] newArray = list.toArray(new Integer[0]);
for (Integer i : newArray) {
System.out.println(i);
}
for(int i = index; i < len ; i++) {
System.out.println(array[i]);
}
}
public List<Integer> reverseArrayByGrpSize(Integer[] arr,int groupSize) {
if(arr.length<1)
throw new NullPointerException("INPUT ARRAY CANNOT BE NULL");
else {
List<Integer> listArr = Arrays.asList(arr);
List<Integer> listArrFinal = new ArrayList<>();
NavigableSet<Integer> revFinal = new TreeSet<>();
int i = listArr.size();
while (i > 0) {
if(groupSize<listArr.size()) {
revFinal.addAll(listArr.subList(0, groupSize));
listArrFinal.addAll(revFinal.descendingSet());
listArr = listArr.subList(groupSize, listArr.size());
revFinal.clear();
i = i - groupSize;
}
else{
revFinal.addAll(listArr.subList(0, listArr.size()));
listArrFinal.addAll(revFinal.descendingSet());
i = 0;
}
}
return listArrFinal;
}
}
public static void main(String[] args) throws IOException {
int[] num = {1,2,3,4,5,6,7,8,9};
int groupSize = 3;
int[] arrayToSort = new int[groupSize];
int counter =0;
int[] newArray = new int[num.length];
for(int i=0; i<num.length; i = i+groupSize)
{
for(int j=i+groupSize; j>i; j--)
{
newArray[counter] = num[j-1];
counter++;
}
}
for(int i=0;i<newArray.length;i++)
{
System.out.println(newArray[i]);
}
}
- michelle.tekk May 08, 2015