Software development engineer ii Interview Questions

Greedy algorithm O(m+n); not really hard once you know it's greedy.

DP can also be used... O(m+n) again...

import java.util.*; class gAlg{ public static void main(String[] args){ int[] a = new int[5]; int[] b = new int[5]; int[] c = new int[5]; int sum= 0; a[0]=2;a[1]=8;a[2]=9;a[3]=7;a[4]=10; b[0]=3;b[1]=2;b[2]=10;b[3]=9;b[4]=9; System.out.println(Arrays.toString(a)); System.out.println(Arrays.toString(b)); int i; for(i=0;i<5;i++){ c[i]=Math.max(a[i],b[i]); sum = sum+c[i]; } System.out.println(Arrays.toString(c)); System.out.println(sum); } }

I have written a program using Hashmap and StringBuilder.

An efficient solution to the problem can done using simple pattern matching. A sample solution goes as follows : public class SampleMain { /** * @param args */ public static void main(String[] args) { String charStream = "ABABCBABABABABABATGBHacbfoabcbahasacbJKOPLMNBGDESRABADACAJALAMNBADDHEMSZPQ"; String noise = "ABCPQR"; System.out.println("CharStream : " + charStream + "\n" + "Noise : " + noise + "\n" + "FliteredCharStream : " + func(charStream, noise)); } private static String func(String charStream, String noise) { String regex = "[" + noise.toLowerCase() + noise.toUpperCase() + "]"; Pattern p = Pattern.compile(regex); Matcher m = p.matcher(charStream); return m.replaceAll(""); } }

import java.util.Arrays; public class Solution{ public static void main(String[] args){ System.out.println(remove("as","asasfsg")); } public static String remove(String s1, String s2){ boolean[] flags = new boolean[255]; char[] a1 = s1.toCharArray(); char[] a2 = s2.toCharArray(); String str = ""; Arrays.fill(flags,false); for(int i=0; i=a1.length && i

One way to do this could be ____________________________________________________ #include #include "math.h" using namespace std; int arr[] = {1,0,4,5,3,2,1,8,0,7}; void test(int a, int b, int c) { if( a*a + b*b == c*c) { cout << "Found a triplet: (" << a << "," << b << "," << c << ")" << endl; } } int main() { int size = sizeof(arr) / sizeof(int); if(size < 3) return -1; for(int a=0; a

Here is a O(n) solution int[] nums = new int[] { 3, 5, 6, 2, 4, 16, 61,8,10,7}; int[] lengths = new int[nums.Max() + 1]; for (int i = 0; i > pythaTriplets = new List> (); for (int i = 2; i ( 2*i,i*i-1,i*i+1)); } } catch { continue;} } pythaTriplets.Dump(); //2x, x*x-1, x*x+1

Its an open ended problem so no perfect solution but they want to see your thinking process. You can use small optimizations and break the problems into parts. Solve each part as best you can

How did you modelled the problem ? Which data strcutures did you used for this problem ?

1. I gave an HashMap> solution. But the interviewer expected a TreeMap solution. But a TreeMap would not be suitable for this question since it will not add elements of same length. 2. I gave him a O(n*d) solution with constant space. He wanted an O(n) with constant space solution which I could not give.

We can use treemap along with comparator to sort based on words length.

Below is the Function for solving the same : int numberOfDigitInK(int k) { int count = 0; while (k % 10 != 0) { k = k / 10; count++; } return count; } int findNextHigherDigit(int k) { int count = this.numberOfDigitInK(k); int higherNumber = 0; int firstDigit = k / (int) Math.pow(10, count - 1); int flag = count; int incrementer = 0; int lastResort = 0; int one = 1; while (flag + 1 > 0) { lastResort += one * Math.pow(10, flag); flag--; one++; } flag = count; while (flag > 0) { higherNumber += firstDigit * Math.pow(10, flag - 1); flag--; firstDigit++; incrementer += 1 * Math.pow(10, flag); } while (higherNumber k) { return higherNumber; } higherNumber += incrementer; } return lastResort; } return lastResort; }

Correct code : int numberOfDigitInK(int k) { int digits = 1 + (int)Math.floor(Math.log10(k)); return digits; } int findNextHigherDigit(int k) { int count = this.numberOfDigitInK(k); int higherNumber = 0; int firstDigit = k / (int) Math.pow(10, count - 1); int flag = count; int incrementer = 0; int lastResort = 0; int one = 1; while (flag + 1 > 0) { lastResort += one * Math.pow(10, flag); flag--; one++; } flag = count; while (flag > 0) { higherNumber += firstDigit * Math.pow(10, flag - 1); flag--; firstDigit++; incrementer += 1 * Math.pow(10, flag); } while (higherNumber k) { return higherNumber; } higherNumber += incrementer; } return lastResort; }

The block shouldn't be holding a strong reference to 'self'.