Zadaci za wannabe pythoniste

Code:

~/.../bmaxa_data/examples >>> cat cyr.cpp                                                           
#include <iostream>

int main() {
    int ćir = 5;
    std::cout << ćir << std::endl;
}
~/.../bmaxa_data/examples >>> g++ -O3 -march=native cyr.cpp                                         
~/.../bmaxa_data/examples >>> ./a.out                                                               
5

Code:
def checkio(text):
    
    "tvoj kod ovde"
    
    return rezultat

#These "asserts" using only for self-checking and not necessary for auto-testing
if __name__ == '__main__':
    assert checkio("My name is ...") == 3, "All words are striped"
    assert checkio("Hello world") == 0, "No one"
    assert checkio("A quantity of striped words.") == 1, "Only of"
    assert checkio("Dog,cat,mouse,bird.Human.") == 3, "Dog, cat and human"
    assert checkio("To take a trivial example, which of us ever undertakes laborious physical exercise, except to obtain some advantage from it?") == 8
    print('If it is done - it is Done. Go Check it NOW!')

Code:
def remove_brackets(a):
    # your code here
    return None


if __name__ == '__main__':
    print("Example:")
    print(remove_brackets('(()()'))

    # These "asserts" are used for self-checking and not for an auto-testing
    assert remove_brackets('(()()') == '()()'
    assert remove_brackets('[][[[') == '[]'
    assert remove_brackets('[[(}]]') == '[[]]'
    assert remove_brackets('[[{}()]]') == '[[{}()]]'
    assert remove_brackets('[[[[[[') == ''
    assert remove_brackets('[[[[}') == ''
    assert remove_brackets('') == ''
    print("Coding complete? Click 'Check' to earn cool rewards!")

Code:
o_lista = ["[","{","("] 
z_lista = ["]","}",")"]

def zagrade(string): 
    stack = []
    out = ''
    stack = [i for i in string if i in o_lista]
    for i in string:
        if i in z_lista: 
            pos = z_lista.index(i)  # pos == 2
            if o_lista[pos] in stack:
                out += o_lista[pos] + z_lista[pos]
                stack.remove(o_lista[pos])
                if len(stack) == 0:
                    return out    
    return out

print(zagrade('({[()}}]]()'))

Code:
# Class Stack implements stack as a list of items
class Stack:
     def __init__(self):
         self.items = []

     def isEmpty(self):
         return self.items == []

     def push(self, item):
         self.items.append(item)

     # Warning: pop from the empty stack raises exception IndexError
     def pop(self):
         return self.items.pop()

     def peek(self):
         return self.items[len(self.items)-1]

     def size(self):
         return len(self.items)



# Utility finctions

# myTranslate removes non-allowed characters from a string
# Parameters:
#     inString (string) input string
#     allowed (string) characters that are allowed
# Output (string):
#     string that contains only allowed characters from the inString
def myTranslate( inString, allowed ):
    # find ALL unique characters in input string (by convarting it into set)
    s=set(inString)
    for i in s:
        if i not in allowed:
            # remove not-allowed characters
            inString = inString.replace(i,'')
    return inString

# myTrim removes from string leading 'left' characters and trailing 'right' characters
# Parameters:
#    inString (string) input string
#    Left (string) leading characters to be removed
#    Right (string) trailing charactes to be removed
# Output (string):
#    left and right trimmed string
def myTrim( inString, Left, Right ):
    start = 0

    # find the position of the FIRST character not in "Left" and remove leading "Left" characters
    for i in range(len(inString)):
        if inString[i] not in Left:
            break 
        else:
            start+=1

    inString = inString[start:]
    
    # Find trailing "Right" characters and remove them from string
    end = 0
    for i in range(len(inString)):
        if inString[-1-i] not in Right:
            break
        else:
            end-=1

    if end == 0:
        return inString

    return inString[:end]
    
# removeChar deletes a single character from string at given position
# Parameters:
#   inString (string): input string
#   pos (int): character position 0..len(inString)-1
def removeChar( inString, pos):

    return (inString[:pos] + inString[pos+1:])


def remove_brackets(a):
    # First, lets define some constants
    OPENING  = '([{'               # List of opening brackets
    CLOSING  = ')]}'               # List of closing brackets
    BRACKETS = OPENING + CLOSING   # List of all brackets
    PAIRS    =  ['{}', '[]', '()'] # List of bracket pairs

    # Local function isValid
    # Parameters:
    #     expression (string): string that contains only brackets
    # Output (Boolean):
    #     True if all opening brackets are matched with corresponding closing brackets in order of apperance
    #     False otherwise
    # Require: Function uses class Stack

    def isValid(expression):
        s=Stack()
        for i in (expression):
            if i in OPENING:
                # opening bracket shuld be pushed to the stack
                s.push(i)
            else:
                # Closing bracket MUST be mached with the opening bracket from the non-empty stack top
                if s.isEmpty() or (s.pop() + i not in PAIRS):
                    # If pair of brackets are not mached, then expression is invalid
                    return False
        
        # if ALL brackets are matched, stack MUST be empty
        if s.isEmpty():
            return True
        # otherwise, brackets are unbalanced
        return False

    a=myTranslate( a, BRACKETS )    # Remove all non-breacket symbols from input string
    a=myTrim( a, CLOSING, OPENING)  # Remove closing brackets from the left side and opening brackets from the right side
                                    # of the input string, since they can not be matched with correcponding bracket

    # Now we have 'clean' string
    checkList = []  # list of potentionally valid bracket expressions

    # expression with balanced brackets MUST have even length, otherwise its useless to check if its valid
    if len(a)%2 == 1:
        for i in range(len(a)):
            # for odd expression length, add to checkList each substring derived from originall string by removing single character from expression
            checkList.append( removeChar( a, i ) )
    else:
        checkList.append(a)

    # Main loop - checking elements from the checkList
    # The first valid string is the result of the function.
    # In case that we checked ALL elemnts from checkList, return empty string

    while checkList != []:
        i = checkList[0]
        if isValid(i):
            # Qapla' (success in Klingon)!!! We made it!!!
            return i
        else:
            # remove the first (checked) element
            checkList.pop(0)
            # generate all substrings of checked element by removing TWO characters from the expression
            # and adding resulting string to the end of list
            for j in range(len(i)-1):
                for k in range(j+1, len(i)):
                    newstring = removeChar( i, k )
                    newstring = removeChar( newstring, j )
                    if newstring not in checkList:
                        checkList.append( newstring )
    
    # we chacked all posible substrings without success
    return ''
   
if __name__ == '__main__':
    print("Example:")
    print(remove_brackets('(()()'))

    # These "asserts" are used for self-checking and not for an auto-testing
    assert remove_brackets('(()()') == '()()'
    assert remove_brackets('[][[[') == '[]'
    assert remove_brackets('[[(}]]') == '[[]]'
    assert remove_brackets('[[{}()]]') == '[[{}()]]'
    assert remove_brackets('[[[[[[') == ''
    assert remove_brackets('[[[[}') == ''
    assert remove_brackets('') == ''
    print("Coding complete? Click 'Check' to earn cool rewards!")

Code:
py .\rb.py
Example:
()()
Coding complete? Click 'Check' to earn cool rewards!

Code:

using System;
using System.Collections.Generic;

namespace INERPRETER_Brackets
{
    class Program
    {
        static bool IsBracket(char c, char lParen, char rParen)
        {
            return (c == lParen) || (c == rParen);
        }

        static bool IsValidString(string str, char lParen, char rParen)
        {
            int cnt = 0;
            for (int i = 0; i < str.Length; i++)
            {
                if (str[i] == lParen)
                    cnt++;
                else if (str[i] == rParen)
                    cnt--;
                if (cnt < 0)
                    return false;
            }
            return (cnt == 0);
        }

        static void RemoveInvalidBracketsByParen(ref string str, char lParen, char rParen)
        {
            if (str == null || str == "")
                return ;

            // zapamti visited string 
            HashSet<string> visit = new HashSet<string>();

            // queue 
            Queue<string> q = new Queue<string>();
            string temp;

            // pushing string kao start node u queue 
            q.Enqueue(str);
            visit.Add(str);
            while (q.Count != 0)
            {
                str = q.Peek(); q.Dequeue();
                if (IsValidString(str, lParen, rParen))
                {
                    return;
                }

                for (int i = 0; i < str.Length; i++)
                {
                    if (!IsBracket(str[i], lParen, rParen))
                        continue;

                    // remove zagradu iz str i gurni u queue ako nije obradjen ranije
                    temp = str.Substring(0, i) +
                           str.Substring(i + 1);
                    if (!visit.Contains(temp))
                    {
                        q.Enqueue(temp);
                        visit.Add(temp);
                    }
                }
            }
        }

        static string RemoveInvalidBrackets(string str)
        {
            RemoveInvalidBracketsByParen(ref str, '(', ')');
            RemoveInvalidBracketsByParen(ref str, '[', ']');
            RemoveInvalidBracketsByParen(ref str, '{', '}');
            return str;
        }

        public static void Main(string[] args)
        {
            Console.WriteLine($"'{RemoveInvalidBrackets("(()()")}'");
            Console.WriteLine($"'{RemoveInvalidBrackets("[][[[")}'");
            Console.WriteLine($"'{RemoveInvalidBrackets("[(}]]")}'");
            Console.WriteLine($"'{RemoveInvalidBrackets("[[{}()]]'")}");
            Console.WriteLine($"'{RemoveInvalidBrackets("[[[[[[")}'");
            Console.WriteLine($"'{RemoveInvalidBrackets("[[[[}")}'");
            Console.WriteLine($"'{RemoveInvalidBrackets("")}'");

        }
    }
}

Code:

'()()'
'[]'
'[]'
'[[{}()]]'
''
''
''