# Open or Close the Parentheses

Every phone needs a calculator app. Because of the limited screen real estate, the developer of mine has decided to save some buttons. Instead of having two dedicated bracket buttons - one for open ( and one for close ) - there is just a single bracket button (). It looks something like this: When the button is pressed, it places a bracket. Based on the input given so far, it predicts whether the bracket should be open ( or close ).

By trial and error, I have found the button to follow these rules:

• If there are no unmatched brackets, the next bracket will always be open (.
• Else, if the last character is a numeral 0123456789 or close ) bracket, the next bracket will be close ).
• Else, if the last character is an operator +-*/ or open ( bracket, the next bracket will be open (.

## The challenge

Based on the given input and the rules mentioned above, predict whether the button places an open ( or close ) bracket.

## Input

Either a string, an array of characters, or anything equivalent. The input will only contain the following characters*: 0123456789+-*/()

## Output

An open ( or close ) bracket or any two consistent values representing them.

## Test cases

""                  -> "("
"(1+"               -> "("
"(1+(2/3"           -> ")"
"(1+(2/3)"          -> ")"
"(1+(2/3))-8"       -> "("
"(1+(2/3))-8*("     -> "("
"(1+(2/3))-8*((5"   -> ")"
"(1+(2/3))-8*((5)"  -> ")"
"(1+(2/3))-8*((5))" -> "("


## Scoring

This is , so the shortest answer in each language wins.

### Note

* The actual calculator also includes the symbols .%, but you don't need to care about those.

• May we assume the input won't contain wonky brackets, e.g. )(1+2? Nov 18, 2021 at 8:31
• @pxeger Yes, you may. You can expect the input to be typed on the calculator, too. Nov 18, 2021 at 8:33
• @Arnauld You can assume that it doesn't contain either. Nov 18, 2021 at 9:25
• These rules aren't correct. For example, the expression ((5+2)(7+3)+4)*2 will not be handled correctly. Instead, your rules will output ((5+2))7+3(+4)*2 Nov 18, 2021 at 14:36
• @DonThousand That is indeed what the calculator does. If you want to force ((5+2)(7+3)+4)*2, then you have to include a multiplication sign after ((5+2). The rules are fine in my opinion. Nov 18, 2021 at 15:35

# JavaScript (Node.js v11.6.0), 48 bytes

a=>/k/.test(eval("try{eval(a+')')}catch(e){e}"))


Try it online!

We try to append a character ')' to the end of expression and eval it. Node v11.6.0 (as current version on TIO) may:

• Calculate the expression if the expression is valid
• The calculate result may only contain characters /[0-9INafinty]/
• Report error SyntaxError: Unexpected token ) if the ) should not be there
• Report error SyntaxError: Unexpected end of input if the ) is valid there

So we just need to check if the result contains letter "k".

• 42
– l4m2
Mar 27 at 18:39
• maybe this count as 39
– l4m2
Mar 27 at 18:40
• @l4m2 Why not simply claim that "My function return results via throwing an exception", and only use code a=>eval(a+')m')?
– tsh
Mar 28 at 2:03
• because I'm not familiar enough with rules
– l4m2
Mar 28 at 16:16
• @l4m2 I'm not sure about the rules. Maybe you can post it as another answer.
– tsh
Mar 29 at 1:55

# C (clang) on Linux, 827966 62 bytes

c;f(*x){for(c=0;*x;++x)*x&22?:*x&1?--c:++c;c*=*--x&16|*x==41;}


Try it online!

Expects a nul-terminated ASCII wide string (4 bytes per character). Returns false (zero) for open bracket and true (nonzero) for close bracket.

• Thank you to @AZTECCO for golfing off 13 bytes!
• And thank you to @jdt for golfing off 4 more bytes. (This required switching to clang; the original answer was for gcc.)
• @AZTECCO You've been busy! And I had no idea C has an Elvis operator now — that's awesome. Nov 20, 2021 at 1:07
• @jdt Very cool. I will include Clang separately, if that's ok with you, since I had gcc originally. Nov 20, 2021 at 1:07
• Sorry for noticing now but it fails on higly unbalanced brackets, e.g. "(((((((((((((()", use *= instead of &= to fix it Try it online! btw lol Elvis operator Nov 20, 2021 at 5:24
• Thanks, I've updated the answer (and merged them). I also swapped the --c and ++c to keep the results nonnegative, for purely aesthetic reasons. Nov 20, 2021 at 5:50
• @ChrisBouchard about the elvis operator: according to Wikipedia leaving out the second operand in the ternary operator is supported as a GCC extension since 2001, so GCC-style C is probably the origin of the elvis operator :-) Nov 21, 2021 at 4:33

# 05AB1E, 18 16 bytes

„()S¢Ëžh')«Iθå≠~


-2 bytes by outputting 1 for ( and 0 for ).

Explanation:

„()        # Push string "()"
S       # Convert it to a character-list: ["(",")"]
¢      # Count the "(" and ")" in the (implicit) input-string
Ë     # Check whether both are the same
žh         # Push builtin "0123456789"
')«     '# Append a ")"
Iθ    # Push the last character of the input-string
å≠  # Check that it's NOT in the string "0123456789)"
~          # Bitwise-OR to check if at least one is truthy
# (after which this is output implicitly as result)


# GNU AWK, 75 bytes

BEGIN{RS=".|"}RT~/$$/{++n}RT~/$$/{--n}END{print n?RT~/[\)0-9]/?")":"(":"("}


Try it online!

BEGIN{RS=".|"}


Starts reading the input one character at a time, which are stored in the RT variable, by the way.

RT~/$$/{++n} RT~/$$/{--n}


If the character is a (, increments n by one. If it is ), decrements n by one.

END{print
n?
RT~/[\)0-9]/?
")"
:"("
:"("
}


If n equals zero, i.e., there are as many ( as ), prints (. If n is different from zero, evaluates the last character (registered in RT). If it is a number or ), prints a ), otherwise, prints (.

• Nice! Changing the non-BEGIN/END clauses to this n+=(RT=="(")-RT==")"{} seems to work and shaves off 2 chars. Nov 21, 2021 at 11:20
• @cnamejj That was a nice idea! But I couldn't make it work without parenthesizing that second comparison, like this: n+=(RT=="(")-(RT==")"){}. Try it online! Nov 21, 2021 at 12:09

# K (ngn/k), 30 bytes

{(^"(*+-/"?*|x)>~+/-/x=/:"()"}


Try it online!

Returns 0 for "(" and 1 for ")".

• ~+/-/x=/:"()" determine whether or not the input contains a balanced number of parenthesis, i.e. that the number of "("s minus the number of ")"s is 0
• (^"(*+-/"?*|x) determine if the last character is one that should be followed by a "(" (i.e. one of "+-*/(") or not
• (...)>... use > as material nonimplication (i.e. only return a truthy value if the left side is truthy and the right side isn't)

# JavaScript (ES6),  52  51 bytes

Expects an array of characters. Returns 0 for (, or 1 for ).

a=>a.map(c=>q+=-(d=c>-1,C=c==')')|c<')',q=0)|q&&d|C


Try it online!

### Commented

a =>               // a[] = input array of characters
a.map(c =>         // for each character c in a[]:
q +=             //   update q
-(             //   which keeps track of the balance of parentheses
d = c > -1,  //   d = digit flag
C = c == ')' //   C = closing parenthesis flag
)              //   decrement q if C is set
| c < ')',     //   or increment it if c is '('
) |                // end of map()
q &&               // return 1 if q is not 0 (unbalanced parentheses)
d                  // and the last character was either a digit
| C              // or a closing parenthesis


# Zsh, 39 bytes

Exits truthy if a ( should be inserted, falsy if a ) should be inserted.

eval ${(s..)1//[^()]/;}||${(M)1%[0-9)]}


Try it online!

The eval handles the matching (getting rid of non-() characters, and spawning nested subshells with spaces and ;s to prevent ()() or (( )) from erroring).

$g=fn($a)=>$a!=chop($a,')0..9')&&($a=count_chars($a))-$a?')':'(';  • Welcome to Code Golf! You might want to move the comment to text in the answer body, to avoid confusion about what is and isn't part of the actual code. Mar 30 at 4:12 • More fundamentally, this answer takes input as a pre-defined variable, which is not an allowed input form Mar 30 at 4:19 # Charcoal, 18 bytes ∨⁼№θ(№θ)№(*+-/§θ±¹  Try it online! Link is to verbose version of code. Outputs - for (, nothing for ). Pretty output can be obtained by prefixing §)( (equivalent to AtIndex(")(", ...). Explanation: Port of @wasif's Python answer.  № Count of ( Literal ( θ In input string ⁼ Is equal to № Count of ) Literal ) θ In input string ∨ Logical Or № Count of §θ±¹ Last character of input string (*+-/ In literal (*+-/ Implicitly print  • @KevinCruijssen Yeah originally I wrote it with the §)( and then forgot which character was at which index... – Neil Nov 18, 2021 at 9:51 • @KevinCruijssen Yeah I noticed your comment on wasif's post, I just wanted the two fixes to be separate edits. – Neil Nov 18, 2021 at 10:00 # Retina 0.8.2, 39 bytes (?>($$)|(?<-1>$$)|.)*$(?<-1>(?<=[\d)]))


Try it online! Outputs 0 for ( or 1 for ), but link is to test suite that maps the results for you. Explanation:

echo $t | ./calc echo done  and it will output either ( or ) to stdout for each test string. # Vyxal, 23 bytes k(↔k(øo[tkd\(+$ck($i|\(  Try it Online! k(↔ # When you remove all but () from the input k(øo # Then remove that until there is no change [ # Is there nothing left? \( # If so, opening bracket | # Else... t # Is the last character of the input...$c        # Contained in...
kd\(+          # Digits + (?
k($i # Index that into ()  • noob here, what does "index that into )(" mean? specifically unsure what "indexing" means in this context, or how you can "index" something into a string or list Nov 18, 2021 at 14:11 • @thejonymyster in this context, "indexing X into Y" essentially means "get the X'th element of Y" Nov 18, 2021 at 17:07 • @Jitse Fixed... Nov 18, 2021 at 18:39 • This can probably lose 4 or so bytes with decision-problem output defaults. Nov 21, 2021 at 10:08 • @UnrelatedString Yeah, but I can't be boothered fixing it. Nov 21, 2021 at 18:47 # Ruby, 47 43 bytes ->e{!!e[/[\d)]$/]&&e.count(?()>e.count(?))}


Try it online!

Outputs True for ), False for (.

• Thanks to @Dingus for the insights and 4 Bytes saved

To choose ) two conditions must hold:

!!e[/[\d)]$/] # match($ at the end) the set of characters [numbers, ')'].
And double negate it to transform nil(no match) to false else true

e.count(?()>e.count(?)) # open brackets can be equal if balanced, else more than closed ones in which case the second condition is met.

• e.count(?()^e.count(?))? Nov 18, 2021 at 18:41
• @emanresu A I'm not sure it's acceptable, it return false or 0 for ( and n>0 for ) but false and 0 are not the same like in many other languages, I may also use =~ instead of === to check last char , it would return nil or 0 for (. Thanks anyways Nov 18, 2021 at 19:55
• @Dingus no worries, many thanks! Indexing into a regex is insane Nov 18, 2021 at 23:42

# PHP (8.0), 110 bytes

<?php
$a=$argv;
$b=ord($a[-1]??'');
die($b>=47||$b==41&&substr_count($a,'(')>substr_count($a,')')?')':'(');


Try it online!

Ungolfed:

<?php
$a =$argv;
// Get the binary value of the first byte of the last character
$lastCharAsciiCode = ord($a[-1] ?? '');
// If the last character in the string is either 0-9 (47-57) OR Closing parenthesis (41)
if ($lastCharAsciiCode >= 47 ||$lastCharAsciiCode == 41) {
// If we have more opening parenthesis than closing, return closing.
if (substr_count($a,'(') > substr_count($a,')')) {
die(')');
}
}
// Return opening by default
die('(');

• You can golf off 2 bytes by removing the newlines after the semicolons. 108 bytes Nov 20, 2021 at 1:35
• Two more suggestions: I don't think you need ?? '' since ord(null) == 0; and you could replace two calls to substr_count with one call to count_chars, which returns an array indexed by character code. 95 bytes Nov 20, 2021 at 1:46
• To clarify, ord(null) == ord('') == 0. Nov 20, 2021 at 1:54
• @ChrisBouchard The null coalesce is to prevent $a[-1] from throwing an exception in the event that$argv is either an empty string or not passed. I'll have a look at your suggestion for count_chars. Thanks! Nov 22, 2021 at 17:52
• I believe accessing an undefined array entry should only be a notice, which is nonfatal. It's up to you, of course, but I don't think advisory messages would be held against you as long as the code produces the correct result. Nov 22, 2021 at 19:50

# R, 57 bytes

function(x)sum((x=="(")-(x==")"))&&grepl("[)0-9]",rev(x))


Try it online!

Input is an array of characters; outputs TRUE if next parenthesis is close ()), FALSE otherwise.

# Rust, 107 104 bytes

|s:&str|(|(n,x)|n==0||x)(s.chars().fold((0,true),|v,c|(v.0+match c{'('=>1,')'=>-1,_=>0},c<'0'&&c!=')')))


Try it online!

true for ( and false for )

## Ungolfed

|s: &str| {
// Iterate over all chars, folding from left
let (paren_counter, ends_with_op_or_open) = s.chars().fold(
(0, true), // Initial value for fold
|(n,_), character| (
// Increment for opening braces and decrement for closing ones
n + match character { '(' => 1, ')' => -1, _ => 0 },
// true for +-*/( but not for 0123456789)
character < '0' && character != ')'
)
);
// Return true if parentheses are balanced or the string ends
// with an operator or open parenthesis, false otherwise
paren_counter == 0 || ends_with_op_or_open
}


# Javascript, 90 chars

s=>s.replace(/.*?([\d)])?$/,(m,c)=>")("[s.replace(/[()]/g,m=>t+=m=='('||-1,t=0),+!(t&&c)])  ## Test: f=s=>s.replace(/.*?([\d)])?$/,(m,c)=>")("[s.replace(/[()]/g,m=>t+=m=='('||-1,t=0),+!(t&&c)])

console.log(
""                  -> "("
"(1+"               -> "("
"(1+(2/3"           -> ")"
"(1+(2/3)"          -> ")"
"(1+(2/3))-8"       -> "("
"(1+(2/3))-8*("     -> "("
"(1+(2/3))-8*((5"   -> ")"
"(1+(2/3))-8*((5)"  -> ")"
"(1+(2/3))-8*((5))" -> "("
.split
.filter(x=>x).map(x=>x.match(/"(.*)".*"(.)"/)).map(([,x,r])=>f(x)==r).every(x=>x))

# brainfuck, 73 bytes

,[+>-->[+]+[->+[--->]<<<]<[->>+<<]>>>[->>-<<],]<[,>>]->[+>[>]--<<<++<+]>.


Try it online!

Outputs truthy for ) and falsy for (. Note that this will fail if there are 256 unmatched (.

Version which outputs '(' or ')' (not particularly golfed)

Explanation:

,[                                           ,]                               loop until end of input
+>-->[+]+[->+[--->]<<<]                                                       paren depth calculation: (brute forced black magic)
'(' => 1
')' => 255
'0123456789+-*/' => 0
<[->>+<<]                                              accumulate paren depth counter
>>>[->>-<<]                                   preserve a data cell uniquely identifying last character
<[,>>]                         if depth counter is nonzero move to cell identifying last character
->[+>[>]--<<<++<+]>.     character to final output calculation: (brute forced black magic)
'+-*/(' or \0 => 0
'0123456789)' => nonzero


# Pip, 17 bytes

$>^pNa&[\d)]$Na


Takes the partial expression as a command-line argument. Outputs 0 for open parenthesis, 1 for close parenthesis. Attempt This Online!

Verify all test cases!

### Explanation

$>^pNa&[\d)]$Na
a is command-line arg; p is "()" (implicit)
^p               Split p into a list of two parenthesis characters
Na             Get the count of each parenthesis in the argument
$> Fold on > (1 if there are more open than close parens, 0 otherwise) (Because we "can expect the input to be typed on the calculator," there will never be more close than open parens) & Logical AND   The following regex: [\d)] Either a digit or a close paren$      followed by end-of-string
N   Count matches in
a  The argument


Thus:

• If the parentheses are balanced, \$> gives 0, which short-circuits the AND and returns 0 (open paren)
• Otherwise:
• If the argument ends with a digit or ), return 1 (close paren)
• If it doesn't, return 0 (open paren)

To get ( and ) as output, wrap the whole thing in (p ... ) for +3 bytes.

• Every time I see pip on Code Golf SE, I wonder for a moment how someone used the Python package manager to solve the challenge. Nov 20, 2021 at 1:59
• @ChrisBouchard And I always wonder how it's possible that the Peripheral Interchange Program is Turing-complete.
– Neil
Nov 21, 2021 at 9:26

# JavaScript (Node.js), 15 bytes

a=>eval(a+')m')


Try it online!

tsh claim that "My function return results via throwing an exception"

# MATLAB, 65 bytes

@(x)all([sum(x(x<42)*2-81),feval(@(a,b)a(end)~=b,[0,x],'/*-+(')])


Try it online! Anonymous function. Outputs logical 1 for ) and logical 0 for (.
Monstrosity with eval is required to handle empty input. Without that case it reduces to:

@(x)all([sum(x(x<42)*2-81),x(end)~='/*-+('])


which is much easier to comprehend. Ungolfed:

@(x)all([                                    % all of the conditions must be met
sum(x(x<42)*2-81)                   % brackets are unbalanced
,                  % AND
x(end)~='/        % last character isn't / AND
*-+('   % isn't * AND ... (so on)
])


Checking of bracket unbalance works by taking only brackets in input: x(x<42) and then with multiplication and subtraction transforming ( into -1 and ) into 1. Then sum of these is converted to logical during execution of all - 0 stays logical 0 anything else becomes logical 1.

Omitted in ungolfed version eval additionaly puts 0 before whole input so last character will always exist.

# Core Maude, 206 bytes

mod B is pr LIST{Int}. ops b p : Nat ~> Nat . var A : Nat . var X Y Z :[Nat]. eq
b(nil)= 0 . eq b(X A)= 0 ^((~ A & 16)*(A xor 41)+ 0 ^ p(X A)). eq p(nil)=
0 . eq p(A X)= 0 ^(A & 22)* -1 ^(A & 1)+ p(X). endm


The result is obtained by reducing the b function with the input string given as a list of ASCII code points. The output will be 0 for open bracket and 1 for close bracket.

### Example Session

Maude> --- "" -> "("
> red b(nil) .
result Zero: 0
Maude> --- "(1+" -> "("
> red b(40 49 43) .
result Zero: 0
Maude> --- "(1+(2/3" -> ")"
> red b(40 49 43 40 50 47 51) .
result NzNat: 1
Maude> --- "(1+(2/3)" -> ")"
> red b(40 49 43 40 50 47 51 41) .
result NzNat: 1
Maude> --- "(1+(2/3))-8" -> "("
> red b(40 49 43 40 50 47 51 41 41 45 56) .
result Zero: 0
Maude> --- "(1+(2/3))-8*(" -> "("
> red b(40 49 43 40 50 47 51 41 41 45 56 42 40) .
result Zero: 0
Maude> --- "(1+(2/3))-8*((5" -> ")"
> red b(40 49 43 40 50 47 51 41 41 45 56 42 40 40 53) .
result NzNat: 1
Maude> --- "(1+(2/3))-8*((5)" -> ")"
> red b(40 49 43 40 50 47 51 41 41 45 56 42 40 40 53 41) .
result NzNat: 1
Maude> --- "(1+(2/3))-8*((5))" -> "("
> red b(40 49 43 40 50 47 51 41 41 45 56 42 40 40 53 41 41) .
result Zero: 0


### Ungolfed

mod B is
pr LIST{Int} .

ops b p : Nat ~> Nat .

var A : Nat .
var X Y Z : [Nat] .

eq b(nil) = 0 .
eq b(X A) = 0 ^ ((~ A & 16) * (A xor 41) + 0 ^ p(X A)) .

eq p(nil) = 0 .
eq p(A X) = 0 ^ (A & 22) * -1 ^ (A & 1) + p(X) .
endm


I hope it's not too cheesy to accept input as ASCII code points. Maude has a string module, but it's pretty weak and kind of verbose.

# Ly, 50 bytes

is<l>0sp["("=l+f")"=fp-sp]<")"=!f'0Lfp*l!+!!")"f-o


Try it online!

The algorithm for this one is:

• read in the input, store the last character in a separate stack
• run through all the chars, track ( vs ) balance in a saved cell
• test, last="(" and last<"0"
• combine those three tests (paren balance is the 3rd one) to pick output

There's a caveat though. I don't think Ly can handle null character (as opposed to numeric) input. So it doesn't handle the first test case, which is a null string.

Here's the sausage making...

First part, get input and setup for run

i        - read the input onto the stack as codepoints
s       - save the last char in the backup cell
<l>    - switch stacks, load backup cell, switch back to original stack
0sp - set the backup cell to "0", then delete 0 from stack


Count the ( vs ) chars, keeping a summary count of the balance

[               p] - process one char per iteration, until stack is empty
"("=              - compare top of stack to "("
l+            - load balance summary, increments on match
f           - flip the current character to the top
")"=       - compare top of stack to ")"
fp     - flip current char to the top, delete it
-    - decrement balance summary if char was ")"
s   - save balance summary to backup cell


Third, test the last character of the input.

<            - switch to the stack where we stashed the last char
")"=        - compare to ")"
!       - negate result, we want "not equal"
f      - pull the character to the top of the stack
'0L   - test if less than character codepoint for "0"
fp - pull the char to the top, then delete it


Fourth, combine the tests to get an output choice

*            - compute "and" of the last two tests
l!          - load balance summary, negate
+         - compute "or" of that and the previous test combo
!!       - convert anything ">0" to "1" via double negate
")"f   - add ")" to stack, pull tests results to top
-  - subtract to change char to "(" if called for
o - output top of stack as a character