DEV Community: shashi

Zilo SDE-2 Backend Interview(2025)

shashi — Wed, 26 Nov 2025 15:20:30 +0000

R1
largest substring with-out repeating charectors

Person
`
Gender
OG1
M
F
M
F
M
M

F
M
F
M
F
F

// Q -> 4
-> with, value , caseSelect id from person p where p.gender =‘M’ —> set1
Select id from person p where p.gender =‘F’. -> set2`

Update person p set p.gender = ‘F’ where p.id in (set1) Update person p set p.gender = ‘M’ where p.id in (set2)

how to do it in single go ?

UPDATE person SET gender = CASE WHEN gender = 'M' THEN 'F' WHEN gender = 'F' THEN 'M' ELSE gender -- optional: keep others unchanged END;

Goldman Sachs SDE-1 Interview Experience (2024)

shashi — Wed, 24 Jul 2024 18:24:52 +0000

import java.util.HashMap;
import java.util.Map;

public class GoldmanSachs {



    /******************************************************************************

     Given an integer array nums and an integer k, return the length of the shortest non-empty subarray of nums
     with a sum of at least k.

     Input : [2,7,3,-8,4,10], target = 12
     Output : 2

     *******************************************************************************/


        static int pathSum=Integer.MAX_VALUE;
        public static void main(String[] args) {
            int nums[] = {2,7,3,-8,4,10};

//      System.out.println(shortest(nums, 12));

            pathSum=dfs(new int[][]   {{ 1, 3 ,1},
                            {1, 5, 1},
                            {4, 2, 1}},
                    0,
                    0,
                    3,
                    3,
                    1,
                    Integer.MAX_VALUE,
                    new HashMap<>()
            );

            System.out.println(pathSum);
            /*. 2, 9, 12, 4, 8, 18*/
        }
        public static int shortest(int nums[], int target){

            int shortestSubArrLen=Integer.MAX_VALUE, n= nums.length ;

            for( int i=0;i<n; i++){
                int currSum=0;

                for( int j=i; j<n; j++){

                    currSum+=nums[j];

                    if( currSum >= target) {
                        shortestSubArrLen=Math.min(shortestSubArrLen, j-i+1);
                        break;
                    }

                }
            }

            return shortestSubArrLen;

        }
    /*
         [ 1, 3 ,1]
         [1, 5, 1]
        [4, 2, 1]

        1 , 1, ,4, 2, ,1. --> 1
                5,  1, 1
                5, 2, , 1




    */


        public static int dfs( int[][] grid, int i, int j, int r, int c,int currSum, int pathSum, Map<String,Integer> cache ){


            String key="";
            if( cache.containsKey(key) ) return cache.get(key);


            if( i>=r || j >=c  || i<0 || j<0) return 0;

            if( i == r-1 && j==c-1) {
                pathSum= Math.min(pathSum , currSum);
                return pathSum ;
            }

            currSum+=grid[i][j];

            //left
            int left= dfs(grid,i, j+1, r, c, currSum,pathSum,cache);

            //bottom
            int right= dfs(grid, i+1,j, r, c, currSum,pathSum,cache);

            return Math.min(left, right);

        }
    }

result : not selected

Winsen SDE-1 Interview Experience (2024)

shashi — Wed, 24 Jul 2024 18:23:17 +0000

import java.util.*;

public class winsen {



    /* T : n^2 S: O(1)    2, 3, 5, 7, */
    public static int  countPrime(int n){
        int count=0;

        for ( int i=2; i<=n; i++){
            if( isPrime(i)) count++;
        }

        return count;

    }

    public static boolean isPrime(int n){
        if( n<2) return  true;

        for( int i=2; i<n ; i++){
            if( n%i==0) return false;
        }
        return  true;
    }




    /*
    *  2, 4, 6, 8
    *  3, 6, 9,
    *  4, 8,
    *  5, 10
    *
    * */
    public static int  countPrimeSteveOfEreross(int n){
         int[] arr = new int[n+1];

        Arrays.fill(arr, 1);

        arr[0]=0;
        arr[1]=0;

        for( int i=2; i<=n; i++){  // O(n)
            int   j=2;
            while ( i*j <= n){  // O(n) ...  O(n^2)
                arr[i*j]=0;
                j++;
            }
        }

        int primeCount=0;
        for(int i: arr) primeCount+=i;
        return  primeCount;
    }


    /*
    *
    * Input: s = "abpcplea",
    * dictionary = ["ale","apple","monkey","plea"]   --> []
      Output: "apple"

       Input: s = "abpcplea", dictionary = ["a","b","c"]
       Output: "a"
    *
    *
    *     T : O (n log(N) ). +   M*N*K
    *
    *
    *
    * */

    public static String lexSmallStringByRemovingSomeCharsFromString( String str, String[] dict){

        List<String>  possibleStrings= new ArrayList<>();
        for( String s : dict){            // T : O(len(dict))
            if( isPossible( str, s)) possibleStrings.add(s);
        }

        if (possibleStrings.isEmpty()) return  "";

        Collections.sort(possibleStrings , (a,b) ->  ( b.length()-a.length())  );  // T : O(nlog(n))

       System.out.println(possibleStrings);

        return  possibleStrings.stream()
                .filter(  strr -> strr.length()==possibleStrings.get(0).length())
                .sorted().findFirst().orElse("");  // T : O(nlog(n))
    }

    public  static  boolean isPossible( String str, String s){
        int m = str.length(), n= s.length(), i=0, j=0;

        while (i<m && j<n){
            if( str.charAt(i) == s.charAt(j)){    // T : O(max(m,n))
              i++;
              j++;
            }else  i++;
        }

      return j == n;

    }


    /**
    *  what is interface?
     * what is difference between hashmap & concurrent hashmap
     * what is functional interface
     * what is SOLID principles
     * what are Design patterns
     * what are error handling methods
     * what is method overloading & overriding
     * what is abstraction & encapsulation
     * what is horizontal scaling & vertical scaling
     * how to make a class immutable
     * what are immutable classes other than String, all wrapper class are immutable for example. Integer, Double,Float, Character etc..
    * */
    }

result : not selected

Zenoti SDE-1 Interview Experience (2024)

shashi — Wed, 24 Jul 2024 18:18:45 +0000

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class Zenoti {

    /*Zenoti dotnet software engineer*/

    /*Online test : Status pass*/

        public static void main1(String args[] ) throws Exception {
            Scanner sc=new Scanner(System.in);
            int n=sc.nextInt();
            while(n > 0){
                String str=sc.next();
                Map<Character,Integer> fhMap=new LinkedHashMap<>();

                for(char ch : str.toCharArray()){
                    fhMap.put(ch, fhMap.getOrDefault(ch,0)+1);
                }

                StringBuilder sb=new StringBuilder();
                for(char ch : fhMap.keySet()){
                    sb.append(ch);
                    sb.append(fhMap.get(ch));
                }
                System.out.println(sb);
                n--;
            }

        }


    public static void main2(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter wr = new PrintWriter(System.out);
        String S = br.readLine();

        String[] out_ = tokenize_string(S);
        for (int i_out_ = 0; i_out_ < out_.length; i_out_++)
        {
            System.out.println(out_[i_out_]);
        }

        wr.close();
        br.close();
    }
    static String[] tokenize_string(String S){
        char[] chr= S.toCharArray();
        int f=-1;
        List<String> str=new ArrayList<>();
        StringBuilder sb=new StringBuilder();
        for(int i=0;i<chr.length;i++){

            if(chr[i]==' ' && f==-1) {
                str.add(sb.toString());
                sb=new StringBuilder();
            }

            if(f!=-1 && chr[i]=='"'){
                sb.append(chr[i]);
                str.add(sb.toString());
                sb=new StringBuilder();
                f=-1;
                continue;
            }

            if(chr[i]=='"'){
                f=i;
            }
            sb.append(chr[i]);
        }

        String[] ans=new String[str.size()];
        for(int i=0;i<str.size();i++){
            ans[i]=str.get(i).trim();
        }


        return ans;
    }

    public static void main3(String args[] ) throws Exception {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        while(n>0){
            String str=sc.next();
            StringBuilder sb=new StringBuilder();

            for(char ch : str.toCharArray()){
                if(ch >=65 && ch <=90){
                    if(sb.length()!=0) sb.append('_');
                    sb.append((char) (ch+32));
                }else{
                    sb.append(ch);
                }
            }

            System.out.println(sb.toString());
            n--;
        }
    }


    /*[19/04/2024] Interview questions on hacker earth : status pass*/

    /**
     *       1
     *     1 2 1
     *   1 2 3 2 1
     * 1 2 3 4 2 3 1
     */

    /*Time : O(N^2) Space :O(1)*/
    public  static  void printPattern(int n) {
        for(int i=0;i<=n;i++) {
            int k=n-i;
            while(k-->0) System.out.print(" ");
            for (int j = 1; j <= i; j++) System.out.print(j +" ");
            for (int j = i-1; j >0; j--) System.out.print(j +" ");
            System.out.println();
        }
    }



    /*Time :O(2^n) Space :O(1) + (call stack space)*/
    public int fib(int n ){
        if(n<2) return  1;
        return fib(n-1)+fib(n-2);
    }

    /*Time :O(n) Space :O(1) + (call stack space)*/
    public int fibMemo(int n,     Map<Integer,Integer> memo){
        if(n<2) return  1;
        if(memo.containsKey(n)) return memo.get(n);
        memo.put(n, fib(n-1)+fib(n-2));
        return memo.get(n);
    }

    /*Time : O(n) Space :O(n)*/
    public int fibTab(int n){
        if(n<2) return 1;
        int[] dp =new int[n+1];
        for(int i=2;i<n;i++)  dp[i]=dp[i-1]+dp[i-2];
        return dp[n];
    }

    /*
    * given three tables, we need to query certain data on the tables;
    *
    * Select students.name from students_table  where id in (
    * select students_id in attendance_table left join
    * lecture_table on attendance_table.lecture_id =lecture_table
    * )
    * order by students.name
    * */


    /* [22/04/2024] :Interview on hacker earth*/
    public static void sortWords(String paragraph){
        String[] words=paragraph.split(" ");
        Arrays.sort(words);
        System.out.println(Arrays.toString(words));
    }

    /*[24/04/2024] : Interview on hacker earth*/
    public void findFirstTwoMax(int[] arr){

        /*constraints:  without sorting  array, without using extra loops */
        int fMax=Integer.MIN_VALUE, sMax=Integer.MIN_VALUE;

        for(int i: arr){
            if(i>fMax){
                sMax=fMax;
                fMax=i;
            }else sMax=Math.max(sMax,i);
        }
        System.out.println(fMax +" , "+sMax);
    }
    public boolean isAnagram(String s, String t){
        int[] asciiArr=new int[256];

        /*constraints: without using extra loops & extra hashmaps*/
        if(s.length()!=t.length()) return false;

        for(int i=0; i<s.length(); i++) {
            asciiArr[s.charAt(i)]++;
            asciiArr[t.charAt(i)]--;
        }

        for(int i:asciiArr)
             if(i>0) return false;

        return true;
    }

    /*sql*/
}

result : not selected

Morning Star SDE-1 Interview Experience (2024)

shashi — Wed, 24 Jul 2024 18:14:53 +0000

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;


/*interviewer  : kalviya, mayur*/
//@RestController
public class Morningstar {

    /*employees , with shashi*/

    class employees{
        private  String name;
    }

//    @GetMapping("/get/{name} ?val= val1& var2=val2")
    public void function(
//            @PathVariable
            String name){

        List<employees> employees= new ArrayList<>();

        employees.stream().filter(employeesRec ->employeesRec.name.equals(name)).collect(Collectors.toList());
    }

    /**
    put : update;
    post : insert data; --> body

    name various spring anotations

     @bean vs @component
     @service

     abstract vs interfaces

     functional interfaces --> not answered

     oops
     object o
     **/

    /*
    *  [Interview 2 :  name starts with g manager]
    *  introduce your self?
    *  what is tech stack?
    *  what is your  experience with postgres?
    *  what is your experience with spring boot?
    *  what is  your experience with python?
    *  what is your experience with gcp?
    *  what is your experience e with the deployments?
    *  what is your experience REST api's?
    *  are you serving notice period?
    *  what are your salary expectations?
    *  why do you want to quit the jsw one platforms?
    *  why do you quit the tvarana ?
    *  what is the recent project you have worked on ?
    *
    * */

}


/* [ mayor told to concentrate on these ]
* Java Basics:
What is the difference between JDK, JRE, and JVM?
JDK (Java Development Kit): It's a software development kit that includes tools for developing Java applications. It contains JRE, compiler, debugger, etc.
JRE (Java Runtime Environment): It's a runtime environment that is needed to run Java applications. It includes JVM and libraries.
JVM (Java Virtual Machine): It's an abstract machine that provides a runtime environment in which Java bytecode can be executed.
*
*
What is the difference between == and equals() method in Java?
== is an operator used to compare references (memory addresses) of objects.
equals() is a method used to compare the content or values of objects. It's overridden from the Object class.

* What is the difference between checked and unchecked exceptions in Java?
  Checked Exceptions: These are checked at compile-time. Methods must either handle them using try-catch blocks or declare them in the method signature using throws keyword.
  Unchecked Exceptions: These are not checked at compile-time. They occur at runtime and are subclasses of RuntimeException. They don't need to be explicitly handled.
  Data Structures and Algorithms (DSA) Basics:
*
*
What is a linked list?
A linked list is a linear data structure consisting of a sequence of elements where each element points to the next element in the sequence.

* Explain the difference between an array and a linked list.
  Array: Fixed size, contiguous memory allocation, random access, efficient for accessing elements by index.
  Linked List: Dynamic size, non-contiguous memory allocation, sequential access, efficient for insertion and deletion at any position.

* What is the time complexity of searching in a binary search tree (BST)?
  The time complexity of searching in a BST is O(log n) on average and O(n) in the worst-case scenario.
*
*
Spring Boot:
What is Spring Boot?
Spring Boot is a framework built on top of the Spring framework that simplifies the process of building and deploying production-ready Java applications.
Explain the concept of auto-configuration in Spring Boot.
Auto-configuration automatically configures Spring beans based on classpath settings, reducing the need for manual configuration.
*
*
What are the main features of Spring Boot?
Simplified dependency management, auto-configuration, embedded HTTP server support, production-ready features (metrics, health checks, etc.), and easy integration with other Spring projects.

*
* Java 8:
  What are the main features introduced in Java 8?
  Lambda expressions, Stream API, Functional interfaces, Default and static methods in interfaces, Optional class, Date and Time API (java.time package), etc.

*
* What is a lambda expression in Java?
  A lambda expression is a concise way to represent an anonymous function. It provides a clear and concise syntax for writing code.

*
* Explain the Stream API in Java 8.
  The Stream API is used to process collections of objects in a functional way. It provides methods to perform aggregate operations on collections such as filter, map, reduce, etc.

    * 10.5, 13.4
    * * */

result : selected

Moengage SDE-2 Interview Experience (2024)

shashi — Wed, 24 Jul 2024 18:13:34 +0000

Dsa question asked

public class Moengage {

/*
    We are focusing on an organized car service station. This station maintains constant service duration for every car.
    Suppose we have n number of customers (1 through n), each with an individual car in need of service. Each customer, denoted as i,
    holds a profit, pi, and a distinct servicing deadline, di.

    Your responsibility is to strategically arrange the servicing of cars in a manner that allows for the number of cars to be
    serviced prior to their individual deadlines to maximize profitability


    Input :
    n= 5
    p= [1, 2 , 2,  3, 4]
    d= [2, 4,  3,  4, 5]  //days


            [2,1] , [3,2] , [4,3] ,[4,2], [5,4]  ⇒   1+ 2+3
            0        1       2          3      4
    t=1

    Max profit  →(  take orders as many as possible ) + ( orders which are payinme more ) //



            5
            2 100
            1 19
            2 27
            1 25
            1 15


            5 * 2


    Int maxProfit( int n, int[] p, int[] d){

        Map< Integer, List< Integers >> dayCarProfitMap = new TreeMap<>();  // i need a sorted list keys

        Int maxDay =Integer.MIN_VALUE;

        for( int i =0 ; i<n ;i++){

            carProfitList = dayCarProfitMap.getOrdefault(  d[ i ] , new ArrayList<>()  );
            carProfitList.add( p[ i ] );

            dayCarProfitMap.put(  d[ i ] , carProfitList    );
        }

        for(  int deadline : dayCarProfitMap. getKeys()  ){

            maxDay= Math.max( maxDay, deadLine);
            Collections.sort ( dayCarProfitMap.get( deadline ) , reverse = true);

        }

        Int profit= 0

        for(  int  day =0 ; day < maxDay  ; day ++) {

            carProfitList = dayCarProfitMap.getFirst( );
            Int currProft= carProfitList.remove( 0 );
            Profit +=    currProft;

            dayCarProfitMap.put( day,  carProfitList);
        }

        Return profit


    }
    */

}

result : not selected

Egen AI SDE-1 Interview Experience (2024)

shashi — Wed, 24 Jul 2024 18:11:22 +0000

System design question

import java.util.*;

public class EgenAi { static class Account {
    private String timestamp;
    private String accountId;
    private Long balance;
    private Long totalTransactions;

    Account(String timestamp, String accountId, Long balance, Long totalTransactions) {
        this.timestamp = timestamp;
        this.accountId = accountId;
        this.balance = balance;
        this.totalTransactions = totalTransactions;
    }

    public void setBalance(Long amount) {
        this.balance = amount;
    }

    public void setTotalTransactions(Long amount) {
        this.totalTransactions = amount;
    }

    public String getAccountId() {
        return accountId;
    }

    public Long getTotalTransactions() {
        return totalTransactions;
    }
}

    static boolean createAccount(String timestamp, String accountId, HashMap<String, Account> db) {
        if (db.containsKey(accountId)) return false;
        db.put(accountId, new Account(timestamp, accountId, 0L, 0L));
        return true;
    }

    static String pay(String timestamp, String accountId, String amount, HashMap<String, Account> db) {
        if (!db.containsKey(accountId) || db.get(accountId).balance < Long.valueOf(amount)) return "";
        Account acc = db.get(accountId);
        acc.setBalance(acc.balance - Long.valueOf(amount));
        acc.setTotalTransactions(acc.getTotalTransactions() + Long.valueOf(amount));
        db.put(accountId, acc);
        return String.valueOf(acc.balance);
    }

    static String deposit(String timestamp, String accountId, String amount, HashMap<String, Account> db) {
        if (!db.containsKey(accountId)) return "";
        Account acc = db.get(accountId);
        acc.setBalance(acc.balance + Long.valueOf(amount));
        acc.setTotalTransactions(acc.getTotalTransactions() + Long.valueOf(amount));
        db.put(accountId, acc);
        return String.valueOf(acc.balance);
    }

    static String topActivity(String timeStamp, String n, HashMap<String, Account> db) {
        StringBuilder sb = new StringBuilder();
        List<Account> valuesList = new ArrayList<>(db.values());

        Collections.sort(valuesList, new Comparator<Account>() {
            @Override
            public int compare(Account a1, Account a2) {
                int compareByTransactions = a2.getTotalTransactions().compareTo(a1.getTotalTransactions());
                if (compareByTransactions == 0) {
                    return a1.getAccountId().compareTo(a2.getAccountId());
                } else {
                    return compareByTransactions;
                }
            }
        });

        int count = 0;
        for (Account account : valuesList) {
            sb.append(account.getAccountId()).append("(").append(account.getTotalTransactions()).append("), ");
            count++;
            if (count >= Integer.valueOf(n)) {
                break;
            }
        }

        if (sb.length() > 0) {
            sb.setLength(sb.length() - 2);
        }

        return sb.toString();
    }

    static String[] solution(String[][] queries) {
        HashMap<String, Account> db = new HashMap<>();
        String[] ans = new String[queries.length];
        int q = 0;

        for (String[] query : queries) {
            if ("CREATE_ACCOUNT".equals(query[0])) {
                ans[q++] = String.valueOf(createAccount(query[1], query[2], db));
            } else if ("DEPOSIT".equals(query[0])) {
                ans[q++] = deposit(query[1], query[2], query[3], db);
            } else if ("PAY".equals(query[0])) {
                ans[q++] = pay(query[1], query[2], query[3], db);
            } else if ("TOP_ACTIVITY".equals(query[0])) {
                ans[q++] = topActivity(query[1], query[2], db);
            }
        }
        return ans;
    }


    /*
    *
    * {{"CREATE_ACCOUNT","1","account1"},
{"CREATE_ACCOUNT","2","account2"},
{"DEPOSIT","3","account1","2000"},
{"DEPOSIT","4","account2","1000"},
{"PAY","5","account1","500"},
{"PAY","6","account1","1000"},
{"PAY","7","account2","1000"}}


{{"CREATE_ACCOUNT","1","account1"},
{"CREATE_ACCOUNT","2","account2"},
{"CREATE_ACCOUNT","3","account3"},
{"DEPOSIT","4","account1","1000"},
{"DEPOSIT","5","account2","1000"},
{"DEPOSIT","6","account3","1000"},
{"PAY","7","account2","100"},
{"PAY","8","account2","500"},
{"PAY","9","account2","2000"},
{"PAY","10","account2","500"},
{"PAY","11","account3","700"},
{"PAY","12","account1","800"},
{"TOP_ACTIVITY","13","2"},
{"TOP_ACTIVITY","14","3"},
{"TOP_ACTIVITY","15","4"}}


{{"CREATE_ACCOUNT","1","account1"},
{"CREATE_ACCOUNT","2","account2"},
{"CREATE_ACCOUNT","3","account3"},
{"DEPOSIT","4","account1","1000"},
{"DEPOSIT","5","account2","1000"},
{"DEPOSIT","6","account3","1000"},
{"PAY","7","account2","100"},
{"PAY","8","account2","100"},
{"PAY","9","account3","100"},
{"TOP_ACTIVITY","10","3"}}
    * */
}

result : not selected

EDRA Labs SDE 1 interview experience (2024)

shashi — Wed, 24 Jul 2024 18:10:31 +0000

question asked to build the system:

public class EdraLabs {

    /**
    * first round is a machine coding round:
    *
    *
    * Design a server capable of generating, assigning, and managing API keys with specific functionalities.
         The server should offer various endpoints for interaction:
         An endpoint to create new keys.
         Each generated key has a life of 5 minutes after which it gets deleted automatically if keep-alive operation is not run for that key (More details mentioned below).

         An endpoint to retrieve an available key, ensuring the key is randomly selected and not currently in use.
         This key should then be blocked from being served again until its status changes. If no keys are available, a 404 error should be returned.

         An endpoint to unblock a previously assigned key, making it available for reuse.
         An endpoint to permanently remove a key from the system.
         An endpoint for key keep-alive functionality, requiring clients to signal every 5 minutes to prevent the key from being deleted.
         Automatically release blocked keys within 60 seconds if not unblocked explicitly.
         Constraints:
         Ensuring efficient key management without the need to iterate through all keys for any operation. The complexity of endpoint requests should be aimed at O(log n) or O(1) for scalability and efficiency.

         Post( /keys: Generate new keys.
         Status: 201


         GET /keys: Retrieve an available key for client use.
         Status: 200 / 404
         Response: { "keyId": "<keyID>" } / {}


         GET /keys/:id: Provide information (e.g., assignment timestamps) about a specific key.
         Status: 200 / 404
         Response:
         {
         "isBlocked" : "<true> / <false>",
         "blockedAt" : "<blockedTime>",
         "createdAt" : "<createdTime>"
         } / {}



         DELETE /keys/:id: Remove a specific key, identified by :id, from the system.
         Status: 200 / 404



         PUT /keys/:id: Unblock a key for further use.
         Status: 200 / 404




         PUT /keepalive/:id: Signal the server to keep the specified key, identified by :id, from being deleted.
         Status: 200 / 404
         *
         *
         *
         *

*      Second round:
*       1. what is recent project
*       2. what are the issues with you project,
*       3. if you are about to design the project from scratch what will be your approach
*       4. if the integer range in  a new programming language is only 0 to 99 , then how will you
*           manage the arthritic operations of 4 digit numbers
        5. how payment operations work in your system.
        6. how to manage the shipments if we are not flow some exisiting.
        7. how do you scale your systems
        8. how can you make sure your are working 24/7
        9. how do you debug your programmes
        10. how to make this efficiently
       make it , until you fake it , i love you untill you make it will 
*
*
*
*
*
*
*
*
*
    * */
}

Birla Pivot SDE-1 Interview Experience (2024)

shashi — Wed, 24 Jul 2024 18:08:45 +0000

Round 1 DSA

import java.util.ArrayList;
import java.util.List;

public class BirlaPivot {

    /* software engineer 1 role: Interview 1 : 


*/
    /*given a array=[3,4,9,7,8,9,13,5] and sum=12 , i need  to find the all the sub arrays which array elements should be splitted in array*/

    /* Time : O(n* max(arr)%sum)  , space : O(n* max(arr)%sum)*/
    public List<List<Integer>> findSubArraysSplittingInputArrayEqualToSum(int[] arr, int sum){
        List<List<Integer>> ans=new ArrayList<>();
        int i=0;
        while(i<arr.length){
                int num=arr[i], s=sum;
                for(int j=0;i<num/sum;i++){
                    List<Integer> subArr=new ArrayList<>();
                    subArr.add(sum);
                    ans.add(subArr);
                }
                int rem=num%sum;
                if(s==sum){
                    List<Integer> subArr=new ArrayList<>();
                    subArr.add(sum);
                    ans.add(subArr);
                }
                i++;
        }
        return ans;
    }


    /*given an array find the max of two numbers difference provided the left --> right, right should be maximum  */
    /*Time :O(n^2) space :O(1)*/
    public int findMaxDiffLeftToRight(int[] arr){
        int max=0;
        for(int i=0;i<arr.length;i++){
            for(int j=i+1;j<arr.length;j++){
                if(arr[j] > arr[i]){
                    max=Math.max(arr[i]-arr[j],max);
                }
            }
        }
        return max;
    }


    /*follow-up : can we decrease the time complexity : solution : yes, we can construct post-max array for every element */
    /*Time : O(n) space :O(n)*/
    public int findMaxDiffLeftToRightPostMaxArray(int [] arr){
        int max=0;
        int[] postMaxArr=new int[arr.length];
        postMaxArr[arr.length-1]=0;

        for(int i=arr.length-2; i>=0; i--){
            postMaxArr[i]=Math.max(postMaxArr[i+1], arr[i]);
        }

        for(int i=0; i<arr.length; i++) {
            max = Math.max(postMaxArr[i] - arr[i], max);
        }
        return max;
    }


    /*follow-up : can we decrease space complexity y : solution yes, since we are using only one element at  a time we can use a single variable instead of array*/
   /*Time :O(n) space :O(1)*/
    public int findMaxDiffLeftToRightSpaceOptimized(int[] arr){
        int max=0 ,postMaxEle=0;
        for(int i=arr.length-2; i>=0; i--){
            postMaxEle=Math.max(postMaxEle, arr[i]);
            max = Math.max(postMaxEle- arr[i], max);
        }
        return max;
    }
}

Round 2 System Design

public class BirlaR2SysDesign {


    /*  [ 15/May/2024 :: 


Question 1: DSA  Time : O(n^2)  Space :O(n)
    * Question 1  ---> Array = [4,5,900,11,15]
        Sum = 12
      * 900 % 12
           Sub arrays : {  {4,5,3} , {12} ..., {6,6}, {5,7}, {8}}


Question 2: Design Kafka,RabbitMQ, GCP Pub Sub System :




     *
     *  { topics --> { id, name}  , Subscribers--- { id, name, topiId}  , messages --{ topicId , scid, msg , status (process/not prosed/ purged) ,
     *   rtryCount, endpoint, timeStamp, lastModified } }
     *
     *  select  sub.id from Subscribers  where topic= id , message,;
     *
     * indexing -->  queries [ indexCount, timestamp, status ]
     * binarySearch
     *
     * while(){
     *   // [200, 500 ]
     *    [(select * message where status= notProces & retryCount < threshold && timestamp < msg.timeStamp + 4days; )] --> collections
     *      .stream()
     *      .parallel()
     *      .map( msg -> perform(msg))
     *
     * @Async
     * perform{
     *   if(REST --> HTTP:200;)
     *      status= processed;
     *          else {
     *          retryCount++;
     *     }
     * }
     * }
     *


 Question 3 : some sql questions


     *  transaction
     *          begin:
     *      save point) delete ->   empId=1;
     *      save point) update -->  empId=1
     *      end
     *         commit
     *
     * locking:


 Question 4 : some spring boot questions


     * all : @controller, @RestController, @Get, @post ,@Put @Delete
     * @Repository, @Service,
     * @Configuration, @Component
     * @Bean
     * @SpringApplication--> @Autoconfig( )
     *
     * @CustomAnnotations{}
     *
     * @Transactional()
     *
     * s.a..........h.i.@gmail.com -->   all dots; @Annotations
     *
     *  step-way , rollback , commit,
     *  queue = []
    *
    12.5 , 11
    */
}

result :
selected

Amazon Interview SDE-1 (2024)

shashi — Wed, 24 Jul 2024 18:04:28 +0000

the question asked was below & my approach and thought process

public class Amazon {

    /*
     * There is a town of N people with k sheriffs. Each person trust some people and mistrust others.
     * The town sheriffs would only trust other sheriffs but would be trusted by everyone else.
     *
     * Given the function:
     * trusts(Person source, Person target) which returns a boolean,
     *
     * Find all the town sheriffs.  ( police --> police) , allPeople --> allPolices
     */
/*

   1 .... N-k -.  .. r.. .. N

           n* (n-k) ---> 1 frist sheriff  ,  O (r-k)  -->  n ^2


           1 ,2 , 3

            sheriff -->  3,
            can't ve--> 1


           1,3 --> true
           2,3 --> false,


           1,2


           1->2 - true
           2->3 - false
           2->4

           */

    /* T : O(n*n) S : O(1)*/
    Person findSherif( Person[] people){


        for( int i=0; i<people.length; i++){

            boolean isSherif=true;

            for( int j=0 ; j< people.length; j++){

                if( i !=j && trusts(people[j], people[i] ) ){
                    isSherif=false;
                    break;
                }
            }

            if( isSherif) return people[i];
        }

        return null;


    }
}

result :
not selected

Nielsen Interview Experience For SDE (2024)

shashi — Wed, 24 Jul 2024 18:01:22 +0000

Round 1 Interview
Hi, everyone In this article I’m sharing my SDE interview experience with Nielson, on 19/04/2024 I went through the interview with Nielsen India for the Mumbai location, they called me on-site for the interview,

I have requested, that I do it online, and they agreed and scheduled an interview hear it went:

Brief interview about my previous work experience,
Then couple of questions about me like, how familiar with Spring Boot, java, cloud deployments etc.
Then the interviewer asked me to solve the question for finding the first non-repeating element in the array (below is how I did, with different approaches and complexity analysis);
Then I asked questions about the company and what they do interviewer explained at a high level after that, the interviewer ended the call, saying that would get back to me;

/*package whatever //do not write package name here */


public class Nielson {
    /* ROLE : Software Engineer_Nielson


     * Given an array of integers of size N, the task is to find the first non-repeating element in this array.
    * arr=[1 ,2, 1, 3, 4]
    *
    *      0 1 2 3 4   --> 1 --> 0,1  , 2 -->1  , 3 ---> 3, ,4---> 4
    *
    * approach 1 :
    *   1. iterate over the array  :  ---> calcualte the frequecy map --> should maintain the order
    *   2. iterata over the created map  --> if( count> 1)   , smiply return that elemtn
    *
    * Time  : O(n) + O(n) + O(log(n)  ==> O(n)
    * Space :  O(n)
    *
    *   Map<Integer,Integer> frqhMap=new HashMap<>();

     * */
    class person {
        String name;
        Integer age;
    }

    public  static  int firstNonRepeating(int[] arr){
        /* it maintains the order*/
           Map<Integer,Integer> frqhMap=new HashMap<>(); /* cpu intensive */

        person[] pAtt= new person[10];


            int n=arr.length;
           /*iterating over the array and hashify the array with freq O(log(0)*/
            for(int i : arr){
                frqhMap.put(i, (frqhMap.containsKey(i) ? frqhMap.get(i) : 0) +1 );
            }

 //            System.out.println(frqhMap);
             for(int i : arr){
                if(frqhMap.get(i)==1) return  i;
            }
            return -1;
    }
}

result :

i'm not selected for the job

JSW ONE Platform SDE-1 Interview Experiance (2022)

shashi — Wed, 24 Jul 2024 17:58:02 +0000

I recently had the opportunity to interview with JSW ONE Platforms, and I’d like to provide you with an overview of the company. JSW ONE Platforms is a technology-driven, product-based company with a primary focus on developing systems that enhance the sales of steel and paints.

ROUND 1 (Technical MCQ Round):

In this initial round, I faced multiple-choice questions covering various core computer science concepts, including DBMS, Operating Systems, Computer Networking, Algorithm Design, Data Structures, Linux, and Web Technologies.

ROUND 2 (Coding Round):

The second round consisted of three coding questions, ranging from easy to challenging. Advancing to the next stage required at least two correct answers. The problems I encountered included:

A basic math problem.
A question related to game theory.
A dynamic programming problem.

ROUND 3 (Group Discussion):
During this round, participants were given a topic and were required to initiate a group discussion with their allocated group. Mentors observed the discussions and selected the top-performing participants to proceed to the next round.

ROUND 4 (Personal Interview):
The final round involved a personal interview with the internal tech team at JSW The interviewers asked me to solve coding problems and posed questions related to system design.

I’m grateful to share that I successfully cleared all these rounds and secured a position at JSW ONE Platforms. The entire selection process spanned approximately four months, so I advise patience to future applicants.