Salesforce Interview Question for SDETs


Country: United States




Comment hidden because of low score. Click to expand.
0
of 0 vote

namespace ArraySortAdvance
{
    public class Program
    {
        public static void Main(string[] args)
        {
            Sorting objSorting = new Sorting();
            List<int> RawList  = objSorting.FillList();
            List<int> SortedList =  objSorting.SortData(RawList,3);
            objSorting.PrintData(SortedList);
            Console.ReadKey();
        }
    }

    public class Sorting
    {
        int maxElements = 100;
        List<int> array = new List<int>();

        public  List<int> FillList()
        {
            Random rnd = new Random();
            for (int i = 0; i < maxElements; i++)
            {
                //array.Add(rnd.Next());
                array.Add(i);
            }
            return array;
        }

        public List<int> SortData(List<int> ArrayToSort, int interval)
        {
            int temp;
            for (int i = 0; i < maxElements; i += interval)
            {
                for (int j = i; j < i + interval && j < maxElements; j++)
                {
                    for (int k = j + 1; k < i + interval && k < maxElements; k++)
                        if (ArrayToSort[j] < ArrayToSort[k])
                        {
                            temp = ArrayToSort[j];
                            ArrayToSort[j] = ArrayToSort[k];
                            ArrayToSort[k] = temp;
                        }
                }
            }
            return ArrayToSort;
        }
        public void PrintData(List<int> ArrayToPrint)
        {
            for (int i = 0; i < maxElements; i++)
                Console.WriteLine(ArrayToPrint[i]);
        }
    }
}

- michelle.tekk May 08, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 votes

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);
	}

}

- Shakti May 08, 2015 | Flag
Comment hidden because of low score. Click to expand.
1
of 1 vote

sort ?!? question is to reverse, not sort...... fail

- gen-x-s May 12, 2015 | Flag
Comment hidden because of low score. Click to expand.
0
of 0 vote

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);
}

}

- Shakti May 08, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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);
	}

}

- Shakti May 08, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 votes

This is definitely not a option, Arrays.sort(arr) is a nlog(n) complexity operation

- HBY May 10, 2015 | Flag
Comment hidden because of low score. Click to expand.
0
of 0 vote

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);
	}

}

- Shakti May 08, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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 ;

}

- Scott May 08, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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--];
}
}

- -Naga May 08, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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--];
	}
}

- Anonymous May 08, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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--];
	}
}

- nchitturi May 08, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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);
    }
}

- Scorpion King May 08, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

# 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}"

- Brett Stahlman May 09, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

#! /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}"

- brettstahlman May 09, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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];
	}
}

- Anonymous May 09, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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];
	}
}

- manojdandy May 09, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 votes

if (start != end && start <= end) {

can be

if (start < end) {

I will not suggest using recursive call for reverse, it could be a problem when array size is big and size is big.

- HBY May 10, 2015 | Flag
Comment hidden because of low score. Click to expand.
0
of 0 vote

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;
}

- mulli2 May 09, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 votes

Not optimized for g == 1

- HBY May 10, 2015 | Flag
Comment hidden because of low score. Click to expand.
0
of 0 vote

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

- pc May 16, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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;
}

- justinm May 18, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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));
}

- zortlord May 19, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

If an interviewer asked me questions like that I would ask them, "What is the correct English syntax for the questions you posed?"

- Higher expectations May 20, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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)

- dataG June 03, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

{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)}

- dataG June 03, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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)

- dataG June 03, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

public static int[] kReverse(int[] A, int k) {
		for (int i = 0; i < A.length; i = i + k) {
			int j = i + (k - 1);
			if (j >= A.length)
				j = A.length - 1;
			int tmp1 = i;
			int tmp2 = j;
			while (tmp1 < tmp2) {
				int tmp = A[tmp1];
				A[tmp1] = A[tmp2];
				A[tmp2] = tmp;
				tmp1++;
				tmp2--;
			}
		}
		return A;
	}

- Rohit Pujar July 17, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

public static int[] kReverse(int[] A, int k) {
		for (int i = 0; i < A.length; i = i + k) {
			int j = i + (k - 1);
			if (j >= A.length)
				j = A.length - 1;
			int tmp1 = i;
			int tmp2 = j;
			while (tmp1 < tmp2) {
				int tmp = A[tmp1];
				A[tmp1] = A[tmp2];
				A[tmp2] = tmp;
				tmp1++;
				tmp2--;
			}
		}
		return A;

}

- Rohit Pujar July 17, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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;
}
}

}

- Anonymous July 19, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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;
			}
		}
			
	}

- Anonymous July 19, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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

- Arun August 01, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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

- Arun August 01, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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

- Arun August 01, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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;
	}

}

- venkatesh yerneni October 01, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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;
	}

}

- venkatesh yerneni October 01, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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));
    }

}

- Ayush Sanghvi December 02, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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));
}
}

- Ayush Sanghvi December 02, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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));
    }
}

- Ayush Sanghvi December 02, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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] + ",");

	}

}

- Suresh Patel December 31, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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)

- HBY December 31, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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;
}
}

- hivejin March 19, 2016 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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);
	}
}

- rohitpratapitm May 10, 2016 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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]

- pranav garg November 12, 2016 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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]

- Pranav.Infosys November 12, 2016 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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;
        }

- .netDecoder June 13, 2017 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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;
        }

- .netDecoder June 13, 2017 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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]);
}
}

- RS October 29, 2017 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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;
        }

}

- andrew November 14, 2017 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

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]);
}
}

- Ankita January 23, 2020 | Flag Reply


Add a Comment
Name:

Writing Code? Surround your code with {{{ and }}} to preserve whitespace.

Books

is a comprehensive book on getting a job at a top tech company, while focuses on dev interviews and does this for PMs.

Learn More

Videos

CareerCup's interview videos give you a real-life look at technical interviews. In these unscripted videos, watch how other candidates handle tough questions and how the interviewer thinks about their performance.

Learn More

Resume Review

Most engineers make critical mistakes on their resumes -- we can fix your resume with our custom resume review service. And, we use fellow engineers as our resume reviewers, so you can be sure that we "get" what you're saying.

Learn More

Mock Interviews

Our Mock Interviews will be conducted "in character" just like a real interview, and can focus on whatever topics you want. All our interviewers have worked for Microsoft, Google or Amazon, you know you'll get a true-to-life experience.

Learn More