We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
/*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;
}
}
}
}
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) {
}
}
Simple Text Editor
You are viewing a single comment's thread. Return to all comments →
import java.io.; import java.util.;
public class Solution {
}
How about using StringBuilder?
even with string builder you are getting time limit exceeded, The trick just lies in using Buffered reader instead of scanner
/*Can some one suggest whats the mistake I made */
import java.io.; import java.util.;
public class Solution {
}
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 {
}