Language: C++

import java.util.*;
import java.math.*;
import java.io.*;
class Main{
	public static InputReader sc;
    public static PrintWriter out;
    public static final long MOD = (long)1e9 + 7L;
    public static void main(String[] args){
    	sc=new InputReader(System.in);	
    	out=new PrintWriter(System.out);
    	int n=sc.nextInt();
    	char[] A=sc.readString().toCharArray();
    	String ans="";
    	Stack<Character> s=new Stack<Character>();
    	for(int i=0;i<n;i++){
    		if(A[i]=='('){
    			s.push(A[i]);
    		}
    		else{
    			if(!s.isEmpty() && s.peek()=='('){
    				s.pop();
    				ans+="()";
    			}
    			else{
    				ans='('+ans;
        			ans+=')';
    			}	
    		}
    		//out.println(ans);
    	}
    	while(!s.isEmpty()){
    		ans+="()";
			s.pop();
    	}
    	out.println(ans);
    	out.close();
    }
    
//    static class Pair{
//    	String x;
//    	int y;
//    	Pair(){
//    		this.x="";
//    		this.y=-1;
//    	}
//    	Pair(String profit,int val,int count){
//    		this.x=profit;
//    		this.y=val;
//    	}
//    	public static Comparator<Pair> Val=new Comparator<Pair>(){
//    		public int compare(Pair p1,Pair p2){
//    			if(p1.x==p2.y){
//    				return p1.y-p2.y;
//    			}
//    			return (int)p1.x-(int)p2.x;
//    		}
//    	};
//    	public int hashCode() {
//    		final int prime = 31;
//    		int result = 1;
//    		result = prime * result + x;
//    		result = prime * result + x;
//    		return result;
//    	}
//    	public boolean equals(Object obj){
//    		if (this == obj)
//    	        return true;
//    	    if (!(obj instanceof Pair)) {
//    	        return false;
//    	    }
//    	 
//    	    Pair p = (Pair) obj;
//    	    if(p.x!=this.x){
//    	    	return false;
//    	    }
//    	    else if(p.y!=p.y){
//    	    	return false;
//    	    }
//    	    return true;
//    	}
//    }
    static class DisjointSet{
    	int n;
    	int[] par;
    	int[] rank;
    	DisjointSet(int n){
    		this.n=n;
    		this.par=new int[n];
    		this.rank=new int[n];
    		makeSet();
    	}
    	void makeSet(){
    		for(int i=0;i<n;i++){
    			par[i]=i;
    			rank[i]=1;
    		}
    	}
    	void union(int x,int y){
    		int parX=parent(x);
    		int parY=parent(y);
    		if(parX!=parY){
    			if(rank[parX]>=rank[parY]){
    				rank[parX]+=rank[parY];
    				rank[parY]=0;
    				par[parY]=parX;
    			}
    			else{
    				rank[parY]+=rank[parX];
    				rank[parX]=0;
    				par[parX]=parY;
    			}
    		}
    	}
    	int parent(int c){
    		int i=c;
    		while(i!=par[i]){
    			i=par[i];
    		}
    		return i;
    	}
    }
    static int gcd(int a,int b){
    	if(b==0){
    		return a;
    	}
    	return gcd(b,a%b);
    	
    }
    static int lcm(int a,int b){
    	int g;
    	if(a<b){
    		g=gcd(b,a);
    	}
    	else{
    		g=gcd(a,b);
    	}
    	return (a*b)/g;
    }
    static long bigmod ( long a, long p, long m ) {
        long res = 1 % m, x = a % m;
        while ( p>0 ) {
            if ( (p & 1)==1 ) res = ( res * x ) % m;
            x = ( x * x ) % m; p >>= 1;
        }
        return res;
    }
    static boolean isPrime(int n){
    	 if (n == 2)
    	        return true;
    	    for (long i = 2; i * i <= n; i++) {
    	        if (n % i == 0)
    	            return false;
    	    }
    	    return true;
    }
    
    static void shuffle(int[] A){
    	for(int i=A.length-1;i>0;i--){
    		int j=(int)(Math.random()*(i+1));
    		int temp=A[j];
    		A[j]=A[i];
    		A[i]=temp;
    	}
    }
    
//	public static class Node implements Comparable<Node>{
//	    int u;
//	    int v;
//	    public Node(){
//	    	;
//	    }
//	    public Node (int u, int v) {
//	    	this.u = u;
//	        this.v = v;
//	    }
//	    
//	    public void print() {
//	        out.println(v + " " + u + " ");
//	    }
//	   
//	    public int compareTo(Node n1){
//	    	return this.u-n1.u;
//	    }
//	}
	public static long pow(long base,long exp,long mod){
		if(exp==0){
			return 1;
		}
		if(exp==1){
			return base;
		}
		long temp=exp/2;
		long val=pow(base,temp,mod);
		long result=val*val;
		result=(result%mod);
		long AND=exp&1;
		if(AND==1){
			result*=base;
			result=(result%mod);
		}
		return result;
	}
	public static BigInteger pow(BigInteger base, BigInteger exp) {
	    if(exp.equals(new BigInteger(String.valueOf(0)))){
	        return new BigInteger(String.valueOf(1));
	    }    
	    if(exp.equals(new BigInteger(String.valueOf(1))))
	        return base;
	    BigInteger temp=exp.divide(new BigInteger(String.valueOf(2)));
	    BigInteger val = pow(base, temp);
	    BigInteger result = val.multiply(val);
	    result=result.remainder(new BigInteger(String.valueOf(MOD)));
	    BigInteger AND=exp.and(new BigInteger(String.valueOf(1)));
	    if(AND.equals(new BigInteger(String.valueOf(1)))){
	        result = result.multiply(base);
	        result=result.remainder(new BigInteger(String.valueOf(MOD)));
	    }    
	    return result;
	}
	    
	static class InputReader {

	    private InputStream stream;
	    private byte[] buf = new byte[8192];
	    private int curChar, snumChars;
	    private SpaceCharFilter filter;

	    public InputReader(InputStream stream) {
	        this.stream = stream;
	    }

	    public int snext() {
	        if (snumChars == -1)
	            throw new InputMismatchException();
	        if (curChar >= snumChars) {
	            curChar = 0;
	            try {
	                snumChars = stream.read(buf);
	            } catch (IOException e) {
	                throw new InputMismatchException();
	            }
	            if (snumChars <= 0)
	                return -1;
	        }
	        return buf[curChar++];
	    }

	    public int nextInt() {
	        int c = snext();
	        while (isSpaceChar(c))
	            c = snext();
	        int sgn = 1;
	        if (c == '-') {
	            sgn = -1;
	            c = snext();
	        }
	        int res = 0;
	        do {
	            if (c < '0' || c > '9')
	                throw new InputMismatchException();
	            res *= 10;
	            res += c - '0';
	            c = snext();
	        } while (!isSpaceChar(c));
	        return res * sgn;
	    }

	    public long nextLong() {
	        int c = snext();
	        while (isSpaceChar(c))
	            c = snext();
	        int sgn = 1;
	        if (c == '-') {
	            sgn = -1;
	            c = snext();
	        }
	        long res = 0;
	        do {
	            if (c < '0' || c > '9')
	                throw new InputMismatchException();
	            res *= 10;
	            res += c - '0';
	            c = snext();
	        } while (!isSpaceChar(c));
	        return res * sgn;
	    }

	    public int[] nextIntArray(int n) {
	        int a[] = new int[n];
	        for (int i = 0; i < n; i++)
	            a[i] = nextInt();
	        return a;
	    }

	    public String readString() {
	        int c = snext();
	        while (isSpaceChar(c))
	            c = snext();
	        StringBuilder res = new StringBuilder();
	        do {
	            res.appendCodePoint(c);
	            c = snext();
	        } while (!isSpaceChar(c));
	        return res.toString();
	    }

	    public boolean isSpaceChar(int c) {
	        if (filter != null)
	            return filter.isSpaceChar(c);
	        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	    }

	    public interface SpaceCharFilter {
	        public boolean isSpaceChar(int ch);
	    }
	}

}



Compiler output:
a.cc:1:1: error: 'import' does not name a type
    1 | import java.util.*;
      | ^~~~~~
a.cc:1:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:2:1: error: 'import' does not name a type
    2 | import java.math.*;
      | ^~~~~~
a.cc:2:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:3:1: error: 'import' does not name a type
    3 | import java.io.*;
      | ^~~~~~
a.cc:3:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:5:15: error: expected ':' before 'static'
    5 |         public static InputReader sc;
      |               ^~~~~~~
      |               :
a.cc:5:23: error: 'InputReader' does not name a type
    5 |         public static InputReader sc;
      |                       ^~~~~~~~~~~
a.cc:6:11: error: expected ':' before 'static'
    6 |     public static PrintWriter out;
      |           ^~~~~~~
      |           :
a.cc:6:19: error: 'PrintWriter' does not name a type
    6 |     public static PrintWriter out;
      |                   ^~~~~~~~~~~
a.cc:7:11: error: expected ':' before 'static'
    7 |     public static final long MOD = (long)1e9 + 7L;
      |           ^~~~~~~
      |           :
a.cc:7:19: error: 'final' does not name a type
    7 |     public static final long MOD = (long)1e9 + 7L;
      |                   ^~~~~
a.cc:8:11: error: expected ':' before 'static'
    8 |     public static void main(String[] args){
      |           ^~~~~~~
      |           :
a.cc:8:29: error: 'String' has not been declared
    8 |     public static void main(String[] args){
      |                             ^~~~~~
a.cc:8:38: error: expected ',' or '...' before 'args'
    8 |     public static void main(String[] args){
      |                                      ^~~~
a.cc:84:12: error: expected unqualified-id before '[' token
   84 |         int[] par;
      |            ^
a.cc:85:12: error: expected unqualified-id before '[' token
   85 |         int[] rank;
      |            ^
a.cc:98:19: error: expected identifier before '(' token
   98 |         void union(int x,int y){
      |                   ^
a.cc:98:20: error: expected unqualified-id before 'int'
   98 |         void union(int x,int y){
      |                    ^~~
a.cc:98:20: error: expected ')' before 'int'
   98 |         void union(int x,int y){
      |                   ~^~~
      |                    )
a.cc:121:6: error: expected ';' after class definition
  121 |     }
      |      ^
      |      ;
a.cc:82:5: error: a storage class can only be specified for objects and functions
   82 |     static class DisjointSet{
      |     ^~~~~~
a.cc:147:12: error: 'boolean' does not name a type; did you mean 'bool'?
  147 |     static boolean isPrime(int n){
      |            ^~~~~~~
      |            bool
a.cc:157:31: error: expected ',' or '...' before 'A'
  157 |     static void shuffle(int[] A){
      |                               ^
a.cc:185:15: error: expected ':' before 'static'
  185 |         public static long pow(long base,long exp,long mod){
      |               ^~~~~~~
      |               :
a.cc:203:15: error: expected ':' before 'static'
  203 |         public static BigInteger pow(BigInteger base, BigInteger exp) {
      |               ^~~~~~~
      |               :
a.cc:203:23: error: 'BigInteger' does not name a type
  203 |         public static BigInteger pow(BigInteger base, BigInteger exp) {
      |                       ^~~~~~~~~~
a.cc:223:20: error: expected ':' before 'InputStream'
  223 |             private InputStream stream;
      |                    ^~~~~~~~~~~~
      |                    :
a.cc:223:21: error: 'InputStream' does not name a type
  223 |             private InputStream stream;
      |                     ^~~~~~~~~~~
a.cc:224:20: error: expected ':' before 'byte'
  224 |             private byte[] buf = new byte[8192];
      |                    ^~~~~
      |                    :
a.cc:224:21: error: 'byte' does not name a type
  224 |             private byte[] buf = new byte[8192];
      |                     ^~~~
a.cc:225:20: error: expected ':' before 'int'
  225 |             private int curChar, snumChars;
      |                    ^~~~
      |                    :
a.cc:226:20: error: expected ':' before 'SpaceCharFilter'
  226 |             private SpaceCharFilter filter;
      |                    ^~~~~~~~~~~~~~~~
      |                    :
a.cc:226:21: error: 'SpaceCharFilter' does not name a type
  226 |             private SpaceCharFilter filter;
      |                     ^~~~~~~~~~~~~~~
a.cc:228:19: error: expected ':' before 'InputReader'
  228 |             public InputReader(InputStream stream) {
      |                   ^~~~~~~~~~~~
      |                   :
a.cc:228:43: error: expected ')' before 'stream'
  228 |             public InputReader(InputStream stream) {
      |                               ~           ^~~~~~~
      |                                           )
a.cc:232:19: error: expected ':' before 'int'
  232 |             public int snext() {
      |                   ^~~~
      |                   :
a.cc:248:19: error: expected ':' before 'int'
  248 |             public int nextInt() {
      |                   ^~~~
      |                   :
a.cc:268:19: error: expected ':' before 'long'
  268 |             public long nextLong() {
      |                   ^~~~~
      |                   :
a.cc:288:19: error: expected ':' before 'int'
  288 |             public int[] nextIntArray(int n) {
      |                   ^~~~
      |                   :
a.cc:288:23: error: expected unqualified-id before '[' token
  288 |             public int[] nextIntArray(int n) {
      |                       ^
a.cc:295:19: error: expected ':' before 'String'
  295 |             public String readString() {
      |                   ^~~~~~~
      |                   :
a.cc:295:20: error: 'String' does not name a type
  295 |             public String readString() {
      |                    ^~~~~~
a.cc:307:19: error: expected ':' before 'boolean'
  307 |             public boolean isSpaceChar(int c) {
      |                   ^~~~~~~~
      |                   :
a.cc:307:20: error: 'boolean' does not name a type; did you mean 'bool'?
  307 |             public boolean isSpaceChar(int c) {
      |                    ^~~~~~~
      |                    bool
a.cc:313:19: error: expected ':' before 'interface'
  313 |             public interface SpaceCharFilter {
      |                   ^~~~~~~~~~
      |                   :
a.cc:313:20: error: 'interface' does not name a type
  313 |             public interface SpaceCharFilter {
      |                    ^~~~~~~~~
a.cc:316:10: error: expected ';' after class definition
  316 |         }
      |          ^
      |          ;
a.cc:221:9: error: a storage class can only be specified for objects and functions
  221 |         static class InputReader {
      |         ^~~~~~
a.cc:318:2: error: expected ';' after class definition
  318 | }
      |  ^
      |  ;
a.cc: In static member function 'static void Main::main(int*)':
a.cc:9:9: error: 'sc' was not declared in this scope
    9 |         sc=new InputReader(System.in);
      |         ^~
a.cc:9:28: error: 'System' was not declared in this scope
    9 |         sc=new InputReader(System.in);
      |                            ^~~~~~
a.cc:10:9: error: 'out' was not declared in this scope
   10 |         out=new PrintWriter(System.out);
      |         ^~~
a.cc:10:17: error: expected type-specifier before 'PrintWriter'
   10 |         out=new PrintWriter(System.out);
      |                 ^~~~~~~~~~~
a.cc:12:13: error: structured binding declaration cannot have type 'char'
   12 |         char[] A=sc.readString().toCharArray();
      |             ^~
a.cc:12:13: note: type must be cv-qualified 'auto' or reference to cv-qualified 'auto'
a.cc:12:13: error: empty structured binding declaration
a.cc:12:16: error: expected initializer before 'A'
   12 |         char[] A=sc.readString().toCharArray();
      |                ^
a.cc:13:9: error: 'String' was not declared in this scope
   13 |         String ans="";
      |         ^~~~~~
a.cc:14:9: error: 'Stack' was not declared in this scope
   14 |         Stack<Character> s=new Stack<Character>();
      |         ^~~~~
a.cc:14:15: error: 'Character' was not declared in this scope
   14 |         Stack<Character> s=new Stack<Character>();
      |               ^~~~~~~~~
a.cc:14:26: error: 's' was not declared in this scope
   14 |         Stack<Character> s=new Stack<Character>();
      |                          ^
a.cc:14:32: error: 'Stack' does not name a type
   14 |         Stack<Character> s=new Stack<Character>();
      |                                ^~~~~
a.cc:14:49: error: expected primary-expression before ')' token
   14 |         Stack<Character> s=new Stack<Character>();
      |                                                 ^
a.cc:16:20: error: 'A' was not declared in this scope
   16 |                 if(A[i]=='('){
      |                    ^
a.cc:22:33: error: 'ans' was not declared in this scope
   22 |                                 ans+="()";
      |                                 ^~~
a.cc:25:33: error: 'ans' was not declared in this scope
   25 |                                 ans='('+ans;
      |                                 ^~~
a.cc:32:17: error: 'ans' was not declared in this scope
   32 |                 ans+="()";
      |                 ^~~
a.cc:35:21: error: 'ans' was not declared in this scope
   35 |         out.println(ans);
      |                     ^~~
a.cc: In constructor 'Main::DisjointSet::DisjointSet(int)':
a.cc:87:22: error: request for member 'n' in '(Main::DisjointSet*)this', which is of pointer type 'Main::DisjointSet*' (maybe you meant to use '->' ?)
   87 |                 this.n=n;
      |                      ^
a.cc:88:22: error: request for member 'par' in '(Main::DisjointSet*)this', which is of pointer type 'Main::DisjointSet*' (maybe you meant to use '->' ?)
   88 |                 this.par=new int[n];
      |                      ^~~
a.cc:89:22: error: request for member 'rank' in '(Main::DisjointSet*)this', which is of pointer type 'Main::Disjo