Welcome to the first programming challenge! Three of these will be posted a week and you can complete it in any language you want.

You get a point for completing an easy challenge, 2 for a medium, and 3 for a hard. For each challenge if you solve it in the least amount of characters you get a bonus point, and if your code runs the fastest when I check it you also get a bonus point. (ties mean everyone who tied gets the bonus point although exact duplicate answers wont count)

Ill be posting a leaderboard that will show the people who have the most points every month

Submissions will be open for a week

As a new hire of bracket inc., you have been tasked with getting rid of excess brackets lying around the facility. You must simplify a series of brackets so that only brackets that dont have a match remain (a match is an opening and closing bracket of the same type beside each other). The final result should have no matches

As an example for the input [(({})({)(()}] the expected output would be [(({)(}]

These are the valid types of brackets: (){}[]

Your system will be tested against 10 different unknown test cases before it is unleashed on the facility. In order to complete this task you must pass all of the test cases.

Any programming language may be used and to submit an answer reply on this post with the code and the language you coded it in

Edit: Clarification, you must take input in from the user using the program instead of them being hardcoded. (makes it easier to test)

  • shape-warrior-t@kbin.social
    2·
    11 months ago

    Here’s an O(n) solution using a stack instead of repeated search & replace:

    closing_to_opening = {')': '(', ']': '[', '}': '{'}
brackets = input()
acc = []
for bracket in brackets:
    if bracket in closing_to_opening:
        if acc and acc[-1] == closing_to_opening[bracket]:
            acc.pop()
        else:
            acc.append(bracket)
    else:
        acc.append(bracket)
print(''.join(acc))

    Haven’t thoroughly thought the problem through (so I’m not 100% confident in the correctness of the solution), but the general intuition here is that pairs of brackets can only match up if they only have other matching pairs of brackets between them. You can deal with matching pairs of brackets on the fly simply by removing them, so there’s actually no need for backtracking.

    Golfed, just for fun:

    a=[]
[a.pop()if a and a[-1]==dict(zip(')]}','([{')).get(b)else a.append(b)for b in input()]
print(''.join(a))
    • brie@beehaw.org
      1·
      11 months ago

      This gave me the idea to do the same in C, but use the argument string itself as the stack to avoid any allocations. It could probably be further optimized.

      #include 

int main(int argc, char **argv)
{
	char map[256] = { 0 };
	map[')'] = '(';
	map['}'] = '{';
	map[']'] = '[';

	while (--argc) {
		char *top, *p, c;
		top = p = *++argv;

		while ((c = *p++)) {
			if (top != *argv && map[(size_t)c] == top[-1]) {
				top--;
			} else {
				*top++ = c;
			}
		}

		*top = 0;

		puts(*argv);
	}
}
    • metiulekm@sh.itjust.worksEnglish
      0·
      10 months ago

      I thought I knew how to resolve the < and > thing, but it didn’t work at all. I guess the sanitizing code is a bit overzealous after the recent vulnerability.

      Anyway, your code will look slightly nicer, at least on the web interface, if you surround it with three backticks, like this

      ```c
void CharShifter(char* string, int LengthOfString, int IdxOfOpenChar);
```
  • skyrod2@programming.dev
    1·
    10 months ago

    Hi! I created a stack-based language called kcats that is meant to be a simple and powerful language and good for small programs like this one. You can read more about it here: https://skyrod-vactai.github.io/kcats/book-of-kcats.html

    Here’s the solution in kcats (assumes the input is on the stack):

    [[\[ \]] [\{ \}] [\( \)]]
"" float
[[[last] dive wrap swap [lookup] dip =]
 [drop pop drop]
 [put]
 if] step
dropdown

    A bit of explanation: First place a mapping of opening bracket to its matching closing bracket on the stack. Then place the empty result which will be modified as we go. Float the input to the top of stack. Then an if statement. The first part of the if statement is the condition: look up the matching close bracket to the last item in the result, see if it equals the current character. If the condition is true, drop the current character and the last item in the result. If not, put the item into the result. Then ‘step’ runs that if statement on each character of the input. Finally, when we’re done we don’t need the mapping of matching brackets anymore, and we drop it.