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.

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