here we pushing the before appending a new one because when there will be a undo we can directly take the previous string from stack annd assign this value to present string.

hope it helps

I was SO used to requiring optimum solutions or else running out of resources, I only made a comment about storing the whole string for undo. I was totally sure the test cases would add and remove and add and remove 10000 chars repeatedly so we'd die if we weren't smart about it.

not all test cases passed,still 3 timeout.

How about using StringBuilder?

/*Can some one suggest whats the mistake I made */

import java.io.; import java.util.;

public class Solution {

 private static final Scanner scanner = new Scanner(System.in);
public static void main(String[] args) {
    /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */

     int q = scanner.nextInt();
      StringBuilder sb = new StringBuilder();
      Stack st = new Stack();
     for(int i=0; i< q; i++){
         int oprn = scanner.nextInt();
        switch(oprn){
         case 1 : {
             String W = scanner.next();
             st.push(sb.toString());
             sb.append(W);
             break;
         }case 2 : {
             st.push(sb.toString());
             int k = scanner.nextInt();
             st.push(sb.toString());
             sb.delete(sb.length() - k, k);
             break;
         }case 3 :{
             int p = scanner.nextInt();
             System.out.println(sb.toString().charAt(p-1));
             break;
         }case 4 :{
              sb.delete(0, sb.length());
              sb.append(st.pop());
              break;
         }

        }
     }
}

}

Did this code work? I wrote the exact logic but mine isnt working.

An improved version is below: 1. StringBuilder is used instead of creating many immutable strings (provides both space and performance improvements) 2. Instead of storing whole string in the stack , only the last update is stored: for additions: +(appended string length), for deletions: (deleted string). This drastically reduces total space used (although adding some extra processing).

import java.io.; import java.util.; public class Solution {

public static void main(String[] args) throws IOException{
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
StringBuilder sb = new StringBuilder();
Stack<String> stack = new Stack<>();
List<Character> result = new ArrayList<>();
for (int i = 0; i < n; i++) {
    String append = null;
    int show = 0;
    int del = 0;
    String inp = br.readLine();
    String arr[] = inp.split(" ");
    int opt = Integer.parseInt(arr[0]);
    switch (opt) {
    case 1:
        append = arr[1];
        sb.append(append);
        stack.push("+" + append.length()); // '+' is used to differentiate between append or delete operation
        break;
    case 2:
        del = Integer.parseInt(arr[1]);
        String delStr = sb.substring(sb.length() - del, sb.length());
        sb.delete(sb.length() - del, sb.length());
        stack.push(delStr);
        break;
    case 3:
        show = Integer.parseInt(arr[1]);
        result.add(sb.charAt(show - 1));
        break;
    case 4:
        String lastOp = stack.pop();
        if(lastOp.charAt(0) == '+') { // undo addition
            sb.delete(sb.length() - Integer.parseInt(lastOp.substring(1)), sb.length()); // omit first character, since it is just append operation marker (+)
        }
       else { // undo deletion
           sb.append(lastOp);
       }
    }
}
try {
    for(Character j:result)
        System.out.println(j);
} catch (Exception e) {

}
}

}

Not really. You can think that this is a simple brute-force solution, which will not win you the interviews.

Try to think of a efficient way storing things in the stack (i.e. store only the info needed foe undo). The code will be much linger