Eu fiz através do comando 'count' que você já ensinou, acho que ficou melhor!! fiz assim: expr = str(input('Digite a expressão: ')) if exp.count('(') == exp.count(')'): print('Sua expressão é válida!!') else: print('Sua expressão não é válida')
Ricardo Carvalho, pois é. Quando tiver a impressão de que produziu uma solução melhor, dê um passo atrás e avalie bem. A sua solução não funciona. Ex. "))) 3 + 1 ((( "seria aceito como válido!
Confesso que não consegui esse, mas vendo a resolução do Guanabara a gente abre a mente pra coisas novas, muito obrigado por compartilhar sua inteligencia e raciocínio conosco!!!
Mano foi o primeiro exercicio desse curso que eu não consegui chegar numa solução, estou a mais de 1 semana nele pois costumo ver a correção só depois que consigo chegar numa solução mesmo com gambiarras kkk mas dessa vez não consegui :( Mas sim, abre muito a mente.
Custei a entender a explicação. Tive que voltar trechos do vídeo várias vezes, e ainda assim não entendia. Depois de voltar trechos incontáveis vezes, ler comentários dos colegas e assistir o vídeo completo pela segunda vez, na velocidade 0.75x, só então consegui entender o raciocínio e a explicação. Digo isso pq, muitos, assim como eu, podem ter tido dificuldade para entender o exercício, mesmo com a explicação do professor, e terem se sentido burros por isso (como eu me senti por um momento kkkk). Mas é questão de persistência, gente! Assiste quantas vezes for necessário, volta os trechos 500 vezes, se precisar colocar o vídeo na velocidade mais lenta que tiver, coloque, mas não desista. Uma hora a gente entende! kkkk Valeu, Guanabara, por esse curso super completo feito com muito carinho e dedicação para nós!
@@FabianoZonta Acho que ele deu uma complicada na resolução , achei esse exercício MUITO fácil . Pra mim o exercício mais difícil foi o de fazer uma lista ordenada sem utilizar o sorted kkkkk
@@Luan-ev1kk pra mim tbm, O guanabara fez um bglh mega complexo pra uma solução bem simples, era só usar o count() e o find() que ja resolvia tudo em 5 linhas. O unico exercicio que n consegui fazer foi aquela lá sem utilizar o Sort() e nem entendi a explicação prefiri passar pra proxima pra eu n fritar minha cabeça
Fique um tempo tentando entender o que isso tinha haver com listas, mas não descobri até o Guanabara falar no começo do vídeo. Eu fiz muito diferente. A minha lógica era contar se a quantidade de "(" era igual a quantidade de ")". Pra isso era só usar o método count para cada item e comparar. Só deu 5 linhas de código. Segue abaixo o código. expr = str(input('Digite sua expressão: ')) if expr.count('(') == expr.count(')'): print('Sua expressão é válida') else: print('Sua expressão não é válida')
Sei que já tem um tempo... na verdade tem um pequeno problema, em nenhuma porção da expressao pode ter mais fecha do que abre parenteses. ") a + b ( " tem o mesmo numero de abre e fecha, mas está incorreta.
#segue parte do meu codigo expressao = "(1 + 1 * (50 / ()(23 - 2))" abre = 0 fecha = 0 correto = True for l in expressao: if l == '(': abre += 1 elif l == ')': fecha += 1 if fecha > abre: correto = False break correto = (abre == fecha) and correto
@@tviegasf o código do Guanabara está correto, se você digitar ") a + b (" vai dar expressão inválida, pois assim que o ")" cair no laço com a pilha vazia já vai dar um break.
"Você nunca vai aprender a programar assistindo um vídeo chamado, "Aprenda a programar". E todo mundo que eu conheço e que programa bem aprenderam todos da mesma forma. Eles tem uma ideia e tentam replicar em forma de código, ou seja, aprendem programando. Então o único conselho que eu tenho para quem quer aprender a programar é, VÁ PROGRAMAR!" - George Hotz (Simplesmente o cara que desenvolveu a própria IA de carros autônomos)
expressao = str(input('Digite sua espressao: ')) aberto = expressao.count('(') fechado = expressao.count(')') if aberto != fechado: print('Expressão INVÁLIDA...') else: print('Expressão VÁLIDA...') fiz dessa forma achei muito simples nao sei se é totalmente correta, mas funciona bem.
Em pleno 2021, curso ainda é o melhor =) resolvi de maneira diferente... a = str(input(' Digite a expressão: ')) paberto = 0 pfechado = 0 for simb in a: if simb == '(': paberto += 1 elif simb == ')': pfechado += 1 if paberto == pfechado: print(f' Sua expressão está certa.') else: print(f' Sua expressão está incorreta.')
Segui uma lógica semelhante, mas de forma diferente. Fiz uma lista apenas com os parênteses e depois analisei. Ficou um pouco mais longo mas fiquei feliz de ter conseguido sozinho! # DESAFIO 083 expressao = (input('Digite uma expressão matemática: ')) lista = [] for i in expressao: if i == '(' or i ==')': lista.append(i) check = 0 for j in lista: if j == '(': check += 1 elif j == ')': check -= 1 if check < 0: break if check == 0: print('Expressão CORRETA!') else: print('Expressão ERRADA!')
Cara custei pra entender isso, estava me sentindo uma merda por que eu não estava de jeito nenhum entendendo, chegou um momento que pensei até em desistir, mas eu persisti muito e consegui entender… não desista galera, persista que uma hora a gente consegue.
Depois de umas horas analisando o código, entendi essa bagassa. Meu amigo como demorei entender isso, tá não foi muito, cerca de 2 horas, mas no espaço tempo dependendo do seu estado de consciência e foco, parecem 4 ou 6 horas. Mas enfim. EXPLICAÇÃO DO CÓDIGO ELE LER CADA CARCATERE DA EXPRESSÂO SE FOR UM CARACTERE ( ABERTO ELE ADICIONA A LISTA (VAI ADICIONANDO OS QUE ACHA) SE FOR UM ) FECHADO ELE VERIFICA SE O TAMANHO DA LISTA É > 0, SE FOR, ELE REMOVE O ÚTIMO CARACTERE DA LISTA SE A LISTA NAO FOR MAIOR QUE 0 OU SEJA, NÃO TEM UM ABERTO (, ELE ADICIONA UM )FECHADO E O TAMANHO DA LISTA PASSA A VALER zer0 SE A LISTA TIVER SÓ 1 CARACTERE ( ou ), A EXPRESSÃO ESTAR CORRETA SENÃO A EXPRESSÃO ESTÁ ERRADA EX EXPRESSÃO CORRETA NA LISTA: DIGITAMOS ((2+1)) É ARMAZENADO NA LISTA (( )) MAS O SEGREDO É QUE O QUE ME CONFUDIO FOI PENSAR QUE A LISTA AUMENTA DE TAMANHO, MAS NA VERDADE A CADA CARACTERE ADICIONADO NELA, O ANTERIOR É REMOVIDO, E O TAMANHO DELA É SEMPRE 0 QUANDO ESTÁ NA ORDEM CORRE DE PARÊNTESES. QUANDO ELE ENCONTRA UM ABERTO ( ELE ADICIONA A LISTA, APOS ENCONTRAR OUTRO A LISTA AUMENTA E FICA MAIRO QUE ZER0, FICANDO ASSIM ( ( 0 1 MAS TODA VEZ QUE A LISTA FICA MAIOR QUE ZERO, ELE APAGA ESSE ULTIMO VALOR DA LISTA COM O MÉTODO POP, CRIANDO ESSA ANIMAÇÃO QUE ENTENDI MENTALMENTE: ( ( ENCONTROU MAIS OUTRO ABERTO 0 1 ( E APAGA ELE 0 ( ( ENCONTROU MAIS OUTRO ABERTO 0 1 ( E APAGA ELE 0 TODA VEZ QUE ELE ENCONTRA UM (, ELE APAGA E O COMPRIMENTO DA LISTA FICA SEMPRE ZER0 TODA VEZ QUE ELE ENCONTRA UM ) FECHADO NA EXPRESSÂO ELE APAGA O ( ABERTO DA ULTIMA POSIÇÃO EXEMPLO ( ( ) ) ELE ARMAZENA 2 ( ( ABERTOS NA LISTA E ENCONTRA 2 ) FECHADO NA EXPRESSÃO TODA VEZ, PRESTA ATENÇÃO, TODA VEZ QUE ELE ENCONTRA UM FECHADO ) NA EXPRESSÃO ELE APAGA O ULTIMO ( ABERTO ARMAZENADO NA LISTA COM O MÉTODO .pop() CRIANDO A ANIMAÇÃO QUE CITEI ANTERIORMENTE SE NÃO, COMO A LISTA ESTARA VAZIA APOS APAGAR OS PARENTESES ( ABERTOS COM OS PARENTESES )FECHADOS DE ACORDO COM A QUANTIDADE PROPORCIONAL, ELE ADICIONA O PARENTESES ) ABERTO DA EXPRESSÃO PRA LISTA PASSAR A VALER ZER0 LISTA == 0 NA EXPRESSÃO if len(lista) > 0: lista.pop() else: lista.append(')') break DIZ QUE SE O TAMANHO DA LISTA FOR > 0, ELE APAGA OS ( MAS AI QUE TEM OUTRO SEGREDO EXISTEM 3 POSSIBILIDADES: 1 NORAML: ((( ))) ENCONTRAR NA LISTA O TAMANHO PROPORCIONAL DE ( A SER APAGADO, TEM 3, APAGA 3 E A LISTA VALE VAZIO MAS COMO REGRA, COMO A LISTA NÃO É MAIOR QUE ZERO, É ADICIONADO O PARENTESES )FECHADO E ELA PASSA A QUE PASSA A VALER ZER0 AGORA 2 DESPROPORCIONAL: (( ) APAGA APENAS 1 (ABERTO POR QUE SÓ TEM 1 FECHADO, A LISTA REALMENTE NÃO É MAIOR QUE ZERO, MAS SE ELA NAO FOR, ELE ADICIONA O ) FECHADO NA LISTA, FAZENDO COM QUE O VALOR PASSE A VALER 1, POR CONTA DISSO A EXPRESSÃO ESTÁ ERRADA 3 POSSIBILIDADE: SUPONHAMOS QUE VOCÊ TENHA DIGITADO ( ) ), O ( SERA APAGADO PELO PRIMEIRO ), E A LISTA APASSARA A SER VAZIA. VAZIO NÃO É UM VALOR, ENTÃO ELE NAO PODE SER DITO COMO MAIOR QUE ZERO, PORTANTO A ADIÇÃO DO PARENTESES ) FECHADO É IGNORADO PELO PROGRAMA, E A LISTA PASSA A NÃO TER NENHUM VALOR, O QUE TORNA A EXPRESSÂO CORRETA. A EXPRESSÂO SÓ SERÁ ACEITA SE O VALOR FOR == 0
Eu fiz um pouquinho diferente: lista = [] ex = str(input('Digite a expressão: ')) for p in ex: if p == '(' or p == ')': lista.append(p) if lista.count('(') == lista.count(')'): print('Sua expressão está correta!') else: print('Sua expressão está errada!') Muito obrigado pelo aprendizado, professor! A dissecação que o Sr faz nos exercícios é sempre muito importante!
#fiz por meio de uma variável em strg aberto = fechado = 0 c = 0 while True: expressao = str(input('Digite a expressão: ')).strip() while c < len(expressao): if '(' in expressao[c]: aberto += 1 if ')' in expressao[c]: fechado += 1 c += 1 if aberto == fechado: print(f'Sua expressão {expressao} é valida')
Estou no meio do curso de "MySQL", vim aqui avisar (07/2018) que são 600K de inscritos. Cara ótimo canal, espero que chegue em 1M logo. Terminei um curso em tecnologia e só comecei a gostar de programação quando esse canal apareceu na minha vida. Já é o 3° curso que faço, iniciei desde março desse ano. Parabéns a toda equipe e ao professor sensacional.
Mais uma aula soberba de resolução de exercícios do Prof. Guanabara. Me fez sentir que tenho uma longa estrada pela frente para dominar vários aspectos da Linguagem Python. Sou novo em programação, apesar dos meus já 42 anos, e talvez por um aspecto pessoal me atenho mais a semântica de um problema. Os vários métodos, classes, tipos primitivos, tipos de variáveis e bibliotecas do Python me faz sentir um artesão. Na verdade estou convicto que programar é uma arte. Não há um único modo de fazer as coisas, de resolver problemas, de programar e criar soluções. Talvez a arte da programação seja o ápice da criatividade humana. Gosto muito de usar variáveis em códigos do Python. Quanto mais simples for a solução encontrada por mim, mais satisfeito fico com a arte "printada", risos!!!. Alguém poderia me explicar em linguagem simples o que é um vetor em programação? Sei um pouco sobre o assunto quando estudei em Álgebra Linear, e na Física Newtoniana, mas parei por aí. Abaixo segue minha simplória solução do problema. Abraços a todos do Curso em Vídeo. lista = [] a = '(' b = ')' n1 = 0 n2 = 0 lista = str(input('Digite a expressão: ')).strip() if (a in lista) and (b in lista): n1 = lista.count(a) n2 = lista.count(b) if n1 == n2: print('Sua expressão está correta!') else: print('Sua expressão está errada!')
Fiz de uma forma diferente e foi muito bom bater minha cabeça pra conseguir fazer dar certo. Aprendi muita coisa fazendo esse código. Além da funcionalidade básica de verificar se a expressão está certa ele também consegue corrigir algumas expressões como: )4-3( * 2 + )45-5( * (23-2) Se quiser pode testar algumas expressões, o código corrige o erro ")(" . No momento não sei se vou atualizar o código pra corrigir mais erros: from time import sleep expression = input('Digite sua expressão: ') verification = (expression.count('(') == expression.count(')')) erro = '' pos = [] pos_fecha = [] pos_new = [] for w,x in enumerate(expression): if x == '(': pos.append(w) print(pos) # for k,l in enumerate(expression): if l == ')': pos_fecha.append(k) print(pos_fecha) # for c,b in zip(pos,pos_fecha): find_fecha = expression.find(')', b) find_abre = expression.find('(', c) print(f'{find_fecha} > {find_abre}') # if find_fecha < find_abre: print('Não está valido') # erro = 'sim' pos_new.append(c) pos_new.append(b) else: print('Valida') # pass rangepos = int(len(pos_new)/2) n = 0 if erro == 'sim': exp_new = list(expression) for c in range(rangepos): exp_new[pos_new[c+n]] = exp_new[pos_new[c+n+1]] exp_new[pos_new[c+n+1]] = '(' n = n + 1 exp_new = (''.join(exp_new)) print(f' Sua expressão está errada! O certo seria {exp_new}') else: print(' Sua expressão passou no primeiro teste, agora vamos para o segundo: ') print('... ') sleep(2) if expression.count('(') == expression.count(')'): print(' Sua expressão passou no teste. Ela é válida!') else: print('Sua expressão não passou do segundo teste e está errada!') # as linhas com comentários foram usadas como debug
Minha solução ficou mais curta, assim: n = (str(input(' Digite sua expressão: '))) aberto = 0 fechado = 0 for c in n: if c == '(': aberto += 1 if c == ')': fechado += 1 if aberto == fechado: print(' Sua expressão está correta') else: print(' Sua expressão está errada') Muito obg por estar me ajudando a entrar nesse mundo da programação, eu só consigo entender se explicarem com 'objetividade e clareza' e vc faz isso muuuuuuito bem, parabéns
Tava fazendo praticamente a mesma coisa, mas percebi uma falha. O código não dá inválido se "fechar" a expressão com ')' antes de ter aberto com '(', só tá contando se o número dos dois bate. Então a expressão: )3(3+3() Tá dando que está correto. obs : depois de 3 anos tu com certeza já deve saber desse problema, mas resolvi comentar para as pessoas que cometer o mesmo erro que nós.
esse é o primeiro canal que dou like antes mesmo de assistir o conteúdo pois tenho certeza que será bom e não quero esquecer de curtir de forma alguma. Parabéns professor! Você é uma inspiração!
Excelente para aprender a lógica. Outra solução sem utilizar a lógica que o professor pretendeu mostrar, mas ainda usando apenas o que foi aprendido até agora seria: expressão = str(input('Digite a expressão: ')) if expressão.count('(') == expressão.count(')'): print('Sua expressão é válida!') else: print('Sua expressão é inválida!') Abraços
Você tem razão Ewerton, mas é compatível com a fase que se encontra no curso e com a proposta do exercício. Você não acha que se formos muito além disso estaríamos mostrando algo que ainda não foi abordado e poderíamos confundir os iniciantes? Não vi a sua sugestão de solução aqui amigo. Compartilhe conosco. Aqui vai uma outra versão que é um pouco melhor mas continua com problemas pois a expressão a+b)*(c+d já não passa, mas a+b(*)c+d passa. Salientom que nãom usei listas pois não foi visto ainda nesta fase do curso. Abraço. expressão = str(input('Digite a expressão: ')) parentesis = '' for elemento in expressão: if elemento in '()': parentesis += elemento if parentesis[0] == '(' and parentesis[-1] == ')': if expressão.count('(') == expressão.count(')'): print('Sua expressão é válida!') else: print('Sua expressão é inválida!')
Acaso deveria ser a minha? Acho que não. Aqui vai uma outra versão que é um pouco melhor mas continua com problemas pois a expressão a+b)*(c+d já não passa, mas a+b(*)c+d passa. Saliento que não usei listas pois não foi visto ainda nesta fase do curso (Correção: tem listas sim nesta fase, mas fica como exemplo de como fazer com string). Muito obrigado ao amigo pelo retorno e caso veja algum erro nesta versão sinta-se à vontade para falar. Abraço expressão = str(input('Digite a expressão: ')) parentesis = '' for elemento in expressão: if elemento in '()': parentesis += elemento if parentesis[0] == '(' and parentesis[-1] == ')': if expressão.count('(') == expressão.count(')'): print('Sua expressão é válida!') else: print('Sua expressão é inválida!')
Realmente você tem razão em dizer que continua com problemas, pois nesse a expressão a*(b+c) que está correta é dada como errada. Sei que você quer melhorar seu código, e não digo que você está errado, mas ao meu ver, não consigo imaginar solução melhor que a do Guanabara, porque ela analisa elemento por elemento dentro de um laço, o que a torna a prova de falhas, se ')' é digitado antes de '(' é executado uma quebra de laço(break), e a expressão é dada como inválida imediatamente, caso contrário ela analisa até o último elemento verificando a quantidade de colchetes e só então a expressão é validada caso possua a mesma quantidade de parênteses que fecham e que abrem.
Muito bom esse exercício. Achei que minha solução estava certa, mas depois que vi a correção percebi que daria erro se eu colocasse um parêntese fechando antes do primeiro abrindo. ex: )a+b( Na minha solução teria dado como certo quando na verdade está errado.
Primeiramente, meu muito obrigado ao Guanabara e a todos os apoiadores por este excelente curso! Sério, a didática é MUITO BOA! Achei a solução do Guanabara para este exercício bem elegante a penso que vai ser bem útil essa ideia de adicionar da lista e remover da mesma para saber se as quantidades são equivalentes. Como vi nos comentários que tinha muita gente pensando para entender a solução dele, resolvi compartilhar a minha que eu acredito ser bem mais fácil de entender. Apenas adicionei os parenteses abertos a uma lista e os fechados à outra lista. Depois comparei o tamanho de ambas essas listas com len(). Se os tamanhos forem diferentes, significa que o número de parenteses fechando ou abrindo não é o mesmo e portanto a expressao é inválida. Se tiver o mesmo número de parenteses fechando e abrindo, a expresão é valida. Por que no final é isso que vai importar, não é mesmo? Se tem 6 parenteses abrindo, vai precisar ter 6 fechando. Se tem 4 abrindo e somente 3 fechando, vai ser inválida, pois falta 1 parenteses fechando. Minha solução: lista = [] lista_aberto = [] lista_fechado = [] expressão = str(input('Digite a expressão:')) for str in expressão: lista.append(str) #esta parte aqui do lista.append(str) não é relevante para o exercício. Coloquei somente para ter a lista toda. Não precisa ter esta parte. #separa em uma lista os parenteses abertos if str == '(': lista_aberto.append(str) #separa em outra lista os parenteses fechados elif str == ')': lista_fechado.append(str) #Compara o tamanho de ambas as listas -> parenteses abertos x parenteses fechados if len(lista_aberto) == len(lista_fechado): print('Expressão válida.') else: print('Expressão inválida.')
Ótima aula, Guanabara! Eu fiz utilizando uma variável que conta a quantidade de parênteses e, se a quantidade for PAR, significa que é uma expressão válida: expressao = str(input('Digite uma expressão com parênteses: ')) quantidade_parenteses = 0 for indice, valor in enumerate(expressao): if valor in '(' or valor in ')': quantidade_parenteses += 1 if quantidade_parenteses % 2 == 0: print('Sua expressão é VÁLIDA.') else: print('Sua expressão é INVÁLIDA. Verifique a ordem e quantidade dos parênteses.')
Também tentei assim, mas ela têm um erro. Se a expressão for: (((a+b)*c por exemplo, você tem 4 parenteses, só que ainda assim está incorreta. O que eu fiz foi, botar cada '(' ')' em uma variável para contar a quantidade e caso as 2 variáveis tenham o mesmo número, ai sim ela está correta no caso: frase = str(input('Digite a expressão: ')) n_parenteses1 = frase.count('(') n_parenteses2 = frase.count(')') if frase[0] in ')': print('Sua expressão está incorreta!!') elif n_parenteses1 == n_parenteses2: print('Sua expressão está válida!') else: print('Sua expressão está incorreta!!')
Meu raciocínio foi bem parecido,mas acho que ficou mais simples de entender... lista = list(input('Digite a sua equação, meu caro ser humano! ')) c1 = 0 for c in lista: if c == '(': c1 += 1 if c == ')': c1 -= 1 if c1 < 0: break if c1 != 0: print('A equação não está correta!') if c1 == 0: print('A equação está correta!')
"if c1 < 0: break" Eu não entendi bem o pq do 'break'. Ele é necessário pra fazer o laço parar? Na minha resolução, eu não coloquei. Não bastaria apenas as linhas: "if c1 != 0: print('A equação não está correta!')"?
Eu só contei se o número de parenteses é par. Pra que todos estejam fechados corretamente, o número obrigatoriamente TEM que ser PAR. Então eu verifiquei se a quantidade de parenteses era par e funcionou direitinho. Segue o código: expressao = input("Digite uma expressão matemática qualquier: ") parentesesAbrindo = "(" parentesesFechando = ")" contaParenteses = expressao.count(parentesesAbrindo) + expressao.count(parentesesFechando) if contaParenteses % 2 != 0: print("Expressão inválida.") else: print("Expressão válida.")
Opa, mas assim dá errado, pq se você tiver 3 parênteses abrindo e um só fechando tipo assim ((a+b)+3*(4+5 essa expressao é inválida, mas seu código irá dizer que é válida, já que o número de parênteses é par. Você precisar ver se o número de parênteses abrindo + os fechando é par. Aí sim, daria certo. Forte abraço!
obs.: a pilha é uma estrutura em que o último que entra é o primeiro que sai. Resumindo a explicação do vídeo: percorre a lista (expr) com for ( for simb in expr ) - se achar parêntese abrindo ( if simb == '(' ), armazena na pilha ( pilha.append('(') ); - se achar parêntese fechando ( if simb == ')' ), remove da pilha ( pilha.pop() ). * ao final, se pilha vazia ( len(pilha) ==0 ), expressão validada; caso contrário, expressão inválida.
Cara, eu procuro sempre simplificar minhas soluções. Antes de ver a correção, pensei: Todo abre parênteses '(' precisa de um fecha parênteses ')', portanto parênteses é uma dupla de simbolos. meu código ficou assim: exp = input('Digite a expressão entre parenteses: ') parenteses_abre = [] parenteses_fecha = [] for caractere in exp: if caractere == '(': parenteses_abre.append('(') elif caractere == ')': parenteses_fecha.append(')') soma_parenteses = len(parenteses_abre) + len(parenteses_fecha) if soma_parenteses % 2 == 0: print('Expressão Válida!') else: print('Expressão invalida') Acredito piamente que não seja a solução mais efetiva, mas resolve o problema proposto.
@@rodrigoasafh1500 obrigado por compartilhar. Você tem a filosofia certa: entregar a solução mais simples que funcione. Depois vc refatora e vê o que pode melhorar. Sobre a solução apresentada, acho que fiz algo assim, mas lembro que se colocasse número par de parênteses abrindo somente, o código daria "expressão válida", mesmo não tendo os parênteses fechando. Na minha opinião esse é um dos desafios mais difíceis de desenvolver uma solução à prova de usuário. Abraço!
@@rodrigoasafh1500opa, tudo bem? Eu fiz muito parecido com você, mas sua solução pode dar um problema se houver número pares tanto de '(' quanto ')'. Eu solucionei isso comparando o tamanho das listas. If len(lista 1) == len(lista2): Print('operação valida') Else: Print('operacao invalida')
Desse modo, se a lista que possuir o "(" for do mesmo tamanho que a lista que possuir o ")", a operação tá valida. Desculpa qualquer erro de digitação, tô no celular 😅
Fiz de outro jeito e deu certo também. Contei o número de parênteses abrindo e o número fechando, aí fiz a comparação entre eles. Se fosse igual estava certo, caso contrário estava errado.
A minha foi similar à do 'Ricardo Carvalho', que comentou acima. Usei a função 'count()' para verificar se o número de parênteses abrindo tem o mesmo número dos parênteses fechando. lista = list() expressao = str(input('Digite a expressão: ')) for n in range(0,len(expressao)): lista.append(expressao[n]) print(lista) pAberto = lista.count('(') pFechado = lista.count(')') if pAberto == pFechado: print('Sua expressão está válida!') else: print('Sua expressão está inválida!')
Eu geralmente gosto de ver os comentários para ver outras resoluções, então vou deixar a minha, já que é bem diferente do professor. lista = list(str(input('Digite um expressão: '))) x = 0 for c in lista: if c == '(': x += 1 if c == ')': x -= 1 if x < 0: break if x == 0: print('A expressão está correta!!') else: print('Sua expressão está errada!')
Vim agradecer pelo conteúdo! Minha solução pra esse exercício foi esta: count = 0 expressao = str(input('Digite uma expressão matemática envolvida em parênteses: ')) for v in expressao: if v == '(' or v == ')': count += 1 if count % 2 == 0: print(f'A expressão {expressao} está correta!') else: print(f'A expressão {expressao} não está correta!')
Eu fiz assim: lista1 = [] lista2 = [] e = input('expressão: ') for c in e: if c == '(': lista1.append(c) elif c == ')': lista2.append(c) if len(lista1) == len(lista2): print('Expressão correta') else: print('Expressão errada')
No início é difícil mas só por a cbç pra funcionar e usar a lógica dentro da expressão: exp = input(' Digite a expressão matemática: ') pa = 0 pf = 0 for a in list(exp): if a == '(': pa += 1 if a == ')': pf += 1 if pa == pf: print('Expessão válida!') else: print('Expressão inválida!')
Eu fiz a mesma lógica que você hahahaha só que utilizei apenas uma variável contadora, eu vou somando e subtraindo nela e depois verifico se ela é igual a 0. Deve estar certo né hahaha
Se quiser eu mando, mas eu não usei lista que nem o Guanabara. Eu sei que o intuito da aula era usar listas, mas eu preferi usar o vetor mesmo, o resultado é o mesmo, e acho até mais fácil de entender. Se quiser eu posso mandar. Quanto ao amigo do comentário acima, eu realmente encontrei erro no código, eu basicamente validava com base no número de vezes que o usuário digitava '(' ou ')'. O problema era se o usuário abria e fechava na mesma quantidade mas fechava primeiro, como por exemplo, "a + b) + c(". Acabei de consertar. Se quiserem o código eu compartilho, mas como disse acima, não usei lista. :(
Consegui de uma maneira que eu achei simples .... role para baixo hehehe expr = str(input("Digite uma expressão:")) pilha = 0 for cont in expr: if cont == "(": pilha += 1 if cont == ")": pilha -= 1 if pilha < 0: break if pilha == 0: print("Sua expressão é valida!!!") else: print("Sua expressão é invalida!!!")
Parabéns pela resolução. O que não entendi é como o código reconhece que essa expressão ))) 8 + 5 ((( está errada. Pelo o que to vendo o código só leva em consideração a quantidade de parenteses e não a posição. Nesse caso a PILHA fica em 0, mas ele deu como expressão invalida.
x = input(print("Digite a expressão:")) y = 0 cont = 0 cont2 = 0 while y < len(x): if x[y] == "(": cont += 1 if x[y] == ")": cont2 += 1 y += 1 if cont == cont2: print("Correto") else: print("Errado")
Fiz esse exercício utilizando o método '.count' e achei que ficou mais fácil: expressão = list(str(input('Digite uma expressão matemática: '))) if expressão.count('(') == expressão.count(')'): print(f'A expressão é válida') else: print(f'A expressão é inválida')
Fiz com um algoritmo diferente, porém chegando ao mesmo resultado :) Para quem quiser ver outra forma de fazer, eis o código: expressao = str(input('Digite a expressão com parênteses: ')) parentesesabertos = list() parentesesfechados = list() for c in expressao: if c == '(': parentesesabertos.append(c) elif c == ')': parentesesfechados.append(c) if len(parentesesabertos) == len(parentesesfechados): print(f'A expressão está correta! Você abriu e fechou {len(parentesesabertos)} parênteses.') else: print(f'A expressão está incorreta! Você abriu {len(parentesesabertos)} parênteses, ' f'porém fechou {len(parentesesfechados)}.')
Fiz bem diferente do vídeo, apenas manipulando a string e if's. Segue o código : e = str(input("Digite sua expressão :")).strip() p1 = e.count("(") p2 = e.count(")") if p1 == p2: print("Sua expressão está correta !") else: print("Sua expressão está incorreta !")
Guilherme Matos Passarini Até pensei nesta possibilidade, mas agora me diga uma expressão que se encontra nesse caso. Não consiguir imaginar. Ex:(a+(b*c)+d) Não deixa de estar correta por exemplo.
não nescessariamente poderia esta assim a)b + a()( ainda continuaria incompleto, alem disso deve usar o while já que ele pediu pra ir digitando ilimitadamente
Melhorei esse desafio e ele reconhece erros de expressão como (x+), (x + 2)(x - 1) ou até (x + 3)/. Vale lembrar que para um computador, entre um parêntesis e outro sempre deve haver um operador. Deu bastante trabalho mas valeu a pena. while True: expressao = str(input('\033[33mDigite uma expressão: ')).replace(' ', '') erro = parentesis_esquerda = parentesis_direita = 0 lista_operadores = ['+', '-', '/', '*', '^'] for p in expressao: if p in '(': parentesis_esquerda += 1 if p in ')': parentesis_direita += 1 if parentesis_direita != parentesis_esquerda: print('\033[31mERRO1: A quantidade de parêntesis não é a mesma. FALTAM PARÊNTESIS') erro = 1 for n in range(0, 10): if f'){n}' in expressao: print('\033[31mERRO2: Existe um parêntesis incorreto à esquerda de um número. FALTA OPERADOR') erro = 2 if f'{n}(' in expressao: print('\033[31mERRO3: Existe um parêntesis incorreto à direita de um número. FALTA OPERADOR') erro = 3 for o in lista_operadores: if f'({o}' in expressao: print('\033[31mERRO4: Existe um parêntesis incorreto à esquerda de um operador. FALTA NÚMERO OU INCÓGNITA') erro = 4 if f'{o})' in expressao: print('\033[31mERRO5: Existe um parêntesis incorreto à direita de um operador. FALTA NÚMERO OU INCÓGNITA') erro = 5 if expressao[-1] in lista_operadores: print('\033[31mERRO6: A expressão termina com operadores. FALTA NÚMERO OU INCÓGNITA') erro = 6 if expressao[0] in lista_operadores: print('\033[31mERRO7: A expressão começa com operadores. FALTA NÚMERO OU INCÓGNITA') erro = 7 if '()' in expressao: print('\033[31mERRO8: A expressão contém parêntesis se encostando. FALTA NÚMERO OU INCÓGNITA') erro = 8 if ')(' in expressao: print('\033[31mERRO9: A expressão contém parêntesis se encostando. FALTA OPERADOR') erro = 9 if erro == 0: print('\033[35mA expressão digitada está correta.') print(10 * '\033[34m-=-') continuar = str(input('\033[33mDeseja digitar uma nova expressão? [S/N]: ')).strip().upper()[0] if continuar == 'N': print('\033[34mOBRIGADO POR UTILIZAR O PROGRAMA!') break print(10 * '\033[34m-=-')
Brabo demais! Só fiz uma correção no seu código: lista_operadores = ['+', '-', '/', '*', '^'] if expressao[0] in lista_operadores: print('\033[31mERRO7: A expressão começa com operadores. FALTA NÚMERO OU INCÓGNITA') erro = 7 Os 2 primeiros itens da lista de operadores são o + e o -, ou seja, negativo e positivo, e isso tornaria -20+(30*3) errado, sendo que um número ser negativo não é um problema. Por isso fiz a seguinte alteração: if expressao[0] in lista_operadores[2:]: dessa forma, o código só vai verificar se a expressão começa com ['/', '*', '^'], o que estaria plenamente incorreto. Mas parabéns cara! O seu código ficou maravilhoso, e se isso já faz um ano, não consigo nem conceber o quão fera você já está nesse tal de Python!
Professor é top!!! Segue meu código: exp = [] aberto = fechado = 0 ed = input('Digite a expressão: ') exp.append(ed) for x in exp[0]: if(x in '('): aberto += 1 if(x in ')'): fechado += 1 if(aberto == fechado): print('A expressão é válida!') else: print('A expressão é inválida!')
Essa foi minha solução: l = [] e = l.append(input('Digite a expressão: ')) if l[0].count('(') == l[0].count(')'): print('Expressão válida') else: print('Expressão Inválida')
resolvido com 2 linhas exp = str(input('Digite a expressão: ')) print('A expressão está correta!' if exp.count('(') == exp.count(')') else 'A expressão está errada!')
@@luch_ml valor = str(input('Digite uma expressão: ')) dir = valor.count('(') esq = valor.count(')') soma = dir + esq if valor[-1] == '(' or valor[0] == ')' or dir != esq: print('Essa Expresão está incorreta!') else: print('Essa Expressão está correta!')
@@relaxingsounds5878 faltou só acrescentar a situação que aparece os parênteses vazios: if '()' in valor or valor[-1] == '(' or valor[0] == ')' or dir != esq:
Muito boa! Eu fiz um que deu pro gasto não pegava expressões erradas do tipo )a+b( expressao = str(input("Digite a sua expressão: ")) abrindo = fechando = 0 for parenteses in expressao: if parenteses == "(": abrindo += 1 elif parenteses == ")": fechando += 1 if abrindo == fechando: print("Sua expressão está válida!") else: print("Sua expressão está errada!")
# 83 Desta vez fiz bem diferente, mas vou replicar o do video para praticar # Primeiro pensei q a expressão deveria ser 100% válida matemáticamente e tive problemas # para imaginar como fazer mas depois de reler o enunicado foi bem fácil na verdade espressao = str(input("Digite uma expressão matemática! ")) aberto = 0 fechado = 0 for c in espressao: if c == '(': aberto += 1 elif c == ')': fechado += 1 if aberto == fechado: print("A expressão é valida! ") else: print("A expressão não é valida! ")
se começar com ')(' na expressão, seu programa considerará válido, mas n deveria. Tente esse aqui expressao = input('Digite a expressão:') lista = [] i=0 for c in expressao: if c == '(' or c == ')': lista.append(c) while True: if lista[0] == ')': print('EXPRESSÃO INVÁLIDA!') print(lista) break; else: while len(lista)>=2: if lista[i] != lista[i+1]: lista.pop(0) lista.pop(0) else: break if len(lista)==0: print('Esssa é uma expressão válida!') break
Fiz de uma forma que verifica se não houve algum fechamento no lugar errado: ex = input('Digite uma expressão matemática: ') if ')(' in ex and ex.index(')') < ex.index('(') or ex.index(')', 1) < ex.index('(', 1): ver = 'errada' else: if ex.count('(') == ex.count(')'): ver = 'correta' else: ver = 'errada' print(f' A expressão está {ver}!')
JEITO QUE EU FIZ SEM USAR LISTA: direita1 = esquerda1 = 0 expressao = str(input('Digite a expressão: ')).strip() for i, v in enumerate(expressao): if v == '(': direita1 += 1 elif v == ')': esquerda1 += 1 if esquerda1 > direita1: print('Expressão Inválida') break else: if i == len(expressao) - 1: print('Expressão Válida')
De primeira eu fiz um programa q só contasse a quantidade d parênteses mas se estivessem na ordem errada ele não identificava... Após a correção ele ficou assim: cont = 0 expr = input('Digite a expressão para ser avaliada: ') c = 0 while c < len(expr): if c == '(': cont += 1 elif c == ')': cont -= 1 c += 1 if cont < 0: break if cont == 0: print('A expressão digitada é valida!') else: print('A expressão digitado não é válida')
eu fiz desta forma. Usei apenas 8 linhas e uma logica mais simples. expr = str(input('Digite sua expressão aqui: ')) aberto = expr.count('(') fechado = expr.count(')') if aberto == fechado: print('Sua expressão é valida') else: print('Sua expressão esta invalida')
Minha solução: *Usei contador* contador = 0 expressão = str(input('Digite a expressão:')) for p in expressão: if p in '()': contador += 1 if contador % 2 == 0: print('Expressão Válida!') else: print('Expressão Inválida')
para n dar erro nesse caso vc teria q fazer assim expr = str(input("Digite a Expressão: ")) pilha = 0 for simb in expr: if simb in "(": pilha += 1 elif simb in ")": pilha -= 1 if pilha == 0: print("Sua expressão está valida") else: print("Sua expressão está errada")
Oi gente, antes eu não tinha conseguido fazer, mas depois do vídeo tive uma ideia que nem precisaríamos da lista, segue como fiz: c = 0 express = str(input('Digite uma expressão: ')) for n in express: if n == '(': c += 1 elif n == ')': c-= 1 if c % 2 == 0: print('Parabéns, sua expressão é válida!') else: print('Sinto muito, sua expressão não foi aprovada')
Essa resolução está errada amigo. Se você colocar "())(" pra testar, ele vai dizer que a expressão está correta., sendo que não está. Mas é simples de resolver. ex = str(input('Digite uma expressão: ')) p1 = ex.count('(') p2 = ex.count(')') if ex[0] == ')' or ex[-1] == '(': print('Expressão errada') else: print('Expressão Errada') if p1 > p2 or p2 > p1 else print('Expressão Correta')
pô meu mano guanabaresco, tu que me ensinou a fazer o programa o mais simples possível, o suficiente para dar certo. Fiz desse jeito, sem usar listas (foi a primeira coisa que me veio à mente): l = str(input('Entre com a expressão: ')) pa = 0 pf = 0 for c in range(len(l)): if l[c] == '(': pa += 1 elif l[c] == ')': pf += 1 if pa == pf: print('A expressão está correta.') else: print('A expressão está incorreta.')
Pensei em fazer usando for, pensei em fazer apenas comparando com ifs em poucas linhas, até mesmo usando contador. A lógica apresentada do professor foi fantástica e vai servir de experiência!
expressao = str(input('\033[36mDigite a expressão: ')) if expressao.count('(') == expressao.count(')'): print('Essa expressão é válida!') else: print('Essa expressão não é válida!')
Manooooooooooooooooo, eu conseguir esse sem a ajuda kkkk Mas fiz algo bem mais simples utilizando o count e com uma posibilidade de erro no começo e no fim de cada expressão (Vai que o usuario tenha problema na cabeça kkk) exp = input("Digite a expressão: ").strip() if exp[-1] != "(" or exp[0] != ")": if exp.count("(") == exp.count(")"): print("Sua expressão está válida! ") else: print("Sua expressão está errada! ") else: print("Sua expressão está errada! ") Suponha que o usuario comece digitando assim: ) ou talvez termine digitando assim: ( Eu fiz o codigo com essa possibilidade. Caso a expressão for diferente de ")" (Inicio) ou "(" (Final), independente da quantidade, a expressão já vai está errada. Utilizei o count para determinar a quantidade de cada um, caso a quantidade dos dois estejam iguais, a expressão é válida!
Pequeno detalhe, se iniciarmos qualquer expressão com ')', logo estará errada. Porém se ti ver um parentes a mais '(', ele retornará a validação como correta, mesmo estando errada. Então eu inseri um detalhe para reconhecer esse erro no começo: exp = str(input('Digite a expressão: ')) teste = list(exp) d = e = 0 for pos, c in enumerate(teste): if pos==0 and teste[0]==')': print('Expressão errada') else: if teste[pos] == '(': d += 1 if teste[pos] == ')': e += 1 if e == d: print('Expressão CORRETA!') else: print('Expressão INCORRETA!')
expressao = str(input('Digite sua expressão: ')) lista = [] for c in expressao: if c == '(': lista.append(c) elif c == ')': lista.pop() if len(lista) == 0: print('Válido') else: print('Inválido')
A solução q eu cheguei foi utilizar um contador que contasse a quantidade de parentes abrindo e fechando, e depois comparar se a quantidade seria a mesma, para a expressão ser válida. Porém, dessa maneira, não é possível verificar se o parente está abrindo ou fechando de forma correta. Ex: )a+b( É uma expressão inválida, pois os parênteses estão invertidos, mas por ter a mesma quantidade abrindo e fechando ele diria que é valida.
Dá pra resolver só com fatiamento de string, bem mais simples. Criei duas váriaveis (A, B) que contam quantas vezes aparecer '(' e ')', respectivamente, e depois uma condição de igualdade entre as variáveis pra saber se a expressão é válida ou não: exp = str(input('Digite uma expressão matemática: ')) a = ex.count('(') b = ex.count(')') print('Sua expressão está CORRETA!' if a == b else 'Sua expressão está ERRADA')
consegui fazer com duas linhas!!!!! ex = str(input('Digite a expressão: ')) print('Expressão válida' if ex.count('(') == ex.count(')') else 'Expressão inválida')
Não. Não conseguiu. Não é só verificar se o número de parênteses abrindo é o mesmo de parênteses fechando. É também verificar se eles fecham e abrem na hora certa. " (6 + 6) )5 + 6( "seria considerado certo, pois há dois parênteses abrindo e dois fechando. Cheque a resolução do vídeo.
Fiz diferente, funcionou... ex = str(input('Digite uma expressão: ')) pa = [] pf = [] for sim in ex: if sim == '(': pa.append(sim) elif sim == ')': pf.append(sim) print(pa) print(pf) if len(pa) == len(pf): print('Sua expressão esta correta.') else: print('Sua expressão esta incorreta.')
@@valterdjunior Eu fui para a aula com uma resolução bem parecida com essa. Só que eu usei um count para cada parênteses abrindo e fechando. Quando eu fiquei testando eu achei esse problema do ")2 + 2(" também. Depois que eu fui entender que estava faltando verificar se estava na ordem correta, como o Guanabara fez cortando cada parênteses a medida que ele achasse seu par. Bugou minha cabeça, mas foi bom que eu aprendi a pensar dessa nova forma.
Eu "esqueci" que tinha que fazer com lista, mas enfim, está ai minha solução: expressao = str(input('Digite uma expressão: ')) abertos = 0 fechados = 0 for letra in expressao: if letra == '(': abertos += 1 if letra == ')': fechados += 1 if abertos == fechados: print('Expressão correta!') else: print('Expressão está errada!')
Fiz diferente! Fiz utilizando a função count e coloquei pra verificar se a quantidade de parentese abrindo "(" é igual a quantidade fechando ")" expressao = input('Digite a expressão: ') exp_list = [] for l in expressao: exp_list.append(l) if exp_list.count('(') == exp_list.count(')'): print('Sua expressão é valida!') else: print('Sua expressão não é valida!')
Fiz, mas queria solucionar a expressão e não consegui! Inclusive se eu abrir e fechar na ordem errada ainda funciona e por isso não acho que acertei! Acho que a solução do vídeo também vai dar erro caso a expressão errada começe fechando um parentesis, ja que a pilha estará vazia nesse momento! Enfim, esperar mais aulas pra resolver as expressões! ex083.py abre = [] fecha = [] exp = str(input('Digite uma expressão que use parenteses abaixo. >>>')) for p, c in enumerate(exp): if '(' in exp[p]: abre.append(c) if ')' in exp[p]: fecha.append(c) print('Expressão válida!' if len(abre) == len(fecha) else 'Expressão inválida!')
Solução sem criar qq tipo de lista ou vetor, é só analizar os pares dos parênteses digitados, vc tem o da esquerda e os da direitas, eles tem que ser iguais, se não, não fecha a expressão!! while True: entrada = str(input('Digite a expressão: ')) para_esquerda = entrada.count('(') para_direita = entrada.count(')') if para_esquerda == para_direita: print(f'Essa expressão {entrada} é válida.') else: print(f'Essa expressão {entrada} é inválida.')
Ué? O meu ficou muito menor, só me lembrei que o professor falou que toda str() é uma lista, aí achei que era desse jeito: num = (str(input('Digite uma expressão: '))) pd = num.count('(') pe = num.count(')') if pd == pe: print('Expressão valida') else: print('Expressão invalida')
@@TavinOriginal haa agora entendi pq o guana fez daquele jeito! Pq eu fiz tipo o do comentário acima! Só contei se era ambos igual e pronto! Mas agora vou verificar se a primeira é ( E não)
Alguém me tire uma dúvida: se o usuário digitar uma expressão contendo ") )", nessa ordem, quando a iteração passar pelo segundo ")" não esvaziará a lista pilha [")"], que estará contendo o primeiro ")" ? Senão, por quê? Pois a regra é clara: se o valor for ")" e len(pilha) != 0, esvazia a lista com o método pop.
Tive a mesma dúvida, mas fazendo alguns testes acho que entendi o que acontece. A lista não vai esvaziar pelo seguinte motivo: o programa só vai adicionar um ")" na lista, caso a pilha estiver vazia, certo? Só que, quando isso acontecer, o programa vai para o _else_ da linha 9, e por isso vai adicionar o ")" na pilha e logo depois dar um *break* no laço. É esse break que vai garantir que o computador não adicione mais um parêntese ")" e caia na situação que você mencionou.
Pelo que vi o ")" serve somente para remover o "(" que o usuário digitou... se você notar se usuário digitar somente ") )" como vc mencionou a lista está zerada, então vai direto para o else, só assim adicionará o ")" na lista e encerrará o programa pois a expressão estará errada, pois na lista foi adicionado o ")". ai o break é para não ficar adicionando mais vezes o ")" na lista ele encerra, e pula para as condições finais.
se tiver '(' e encontrar outro igual ,ele soma ficando 2 '(' , se em seguida encontrar ')', vai diminuir 1, ai fica apenas um '(' que só será = 0 se tiver outra ')' . Iguais soma e difrerentes diminui. Deu certo pra mim assim!
Caraaaca, essa explicacao foi muito alem do meu raciocinio: Segue minha contribuicao e = input('Type a expression: ') p1 = list(e) c1 = p1.count('(') c2 = p1.count(')') if c1 == c2: print('The expression is correct.') else: print('The expression is incorrect.')
Eu fiz esse em 5 linhas, basicamente é só contar o número de parenteses que abrem e que fecham e verificar se são iguais: exp = input('Digite a expressão: ') if exp.count('(') == exp.count(')'): print('A expressão está correta!') else: print('A expressão está errada!')
A) Refazer B) copiar a resposta C) acertou D) desiste Escolha A isso mostra que você é humilde para assumir, corajoso por admitir e esforçado por tentar. Escolha B mostra que você está tentando de um jeito superficial e não está dedicado e se esforçando a alegria de conseguir será razoável Escolha C mostra que você é eficiente e treinou se dedicou e se destaca dos demais e tem um alcance acima de alguns, brilhante Se você desiste D é apenas algo passageiro na sua vida E a dúvida de que você não consegue fazer as coisas e todos é mais esperto que você ou você não liga ou é diferente das outras pessoas . Nunca , jamais desista não importa o que os outros dizem o quanto riem Siga em frente , deixe eles falarem não importa, apenas estude e não desista !!! Seremos grandes e suficientes para se garantir em Python !!!🫡
Eu fiz desse jeito h = input("Digite a expressão") if h.count('(') > h.count(")") or h.count(')') > h.count("("): print("Expressão invalida") else: print("Expressão valida")
expressao = input('Digite uma expressão: ').strip() lista = [] for c in expressao: if c == ')' or c == '(': lista.append(c) contando = len(lista) if contando % 2 == 0: print('Sua expressão está válida!') else: print('Sua expressão está errada !') , esse exercício pensei que era difícil, mas em menos de 10 min terminei ele.
Fiz de uma maneira simples: exp = str(input('Digite a expressão: ')) if exp.count('(') == exp.count(')') and exp.index('(') < exp.index(')'): print('Expressão válida') else: print('Expressão inválida')
Fiz de um jeito diferente. Usei o count para contar a quantidade de '(' e ')' , depois, verifiquei se a quantidade de ambos era a mesma: expressao = [] conta = input('Digite a expressão: ') aberto = conta.count('(') fechado = conta.count(')') if aberto == fechado: print('Sua expressão está correta') else: print('Sua expressão está errada')
Utilizei o método count! Assim o programa ficou menor e mais simples de entender. expressão = (input('Digite sua expressão para verificar se está certa ou errada: ')) cont1 = expressão.count('(') cont2 = expressão.count(')') print(f'Esta é a sua expressão: {expressão}. ') if cont1 == cont2: print('Sua expressão está correta!') else: print('Sua experssão está incorreta.')
feliz por ter consegui resolver mais um sem olhar a resposta..... minha solução foi diferente.... ainda acrescentei o erro, segue aí... expressão = str(input('digite uma expressão')) abre = (expressão.count('(')) fecha = (expressão.count(')')) print (f'a expressão digitada foi {expressão}') if abre == fecha: print(f'sua expressão é valida') elif abre > fecha: print('expressão inválida, tem mais "(" abrindo do que fechando') else: print('expressão inválida, tem mais ")" fechando do que abrindo')
Fiz dessa maneira, tecnicamente toda vez que abrir um '(' vai ter que ter outro ')', utilizei o count para contar os elementos e alimentei uma variável , depois só comparei as duas e caso a quantidade de ( ou ) fosse impar , retornaria a mensagem lista = [] valor = input('Digite uma expressão: ') parenteses_esquerda = valor.count('(') parenteses_direita = valor.count(')') if parenteses_direita == parenteses_esquerda: print('A sua expressão é valida!') else: print('A sua expressão é invalida!')
Fiz uma solução que funciona, mas detectei um bug durante essa correcção, felizmente consegui compreender o motivo do bug e ajustar o código, fiquem atentos, não é só somar o valores de '(' e ')' e compará los que o resultado será correto, teste com a seguinte expressão '(a*b)-)c(=12' o retorno deve ser o de um expressão invalida.
Na minha resolução fiz o programa analisar cada parte da expressão . Se o parenteses abre, ele adiciona em uma lista, se ele fecha, ele é adicionado em outra lista, no final, as duas tem que ter o mesmo comprimento. parentesesr_abre = [ ] parenteses_fecha= [ ] expressao = input( 'Digite a expressão: ') for c in expressao: if c == ' ( ': parenteses_abre.append( ' ( ' ) elif c == ' ) ': parenteses_fecha.append( ' ) ' ) if len(parenteses_abre) == len(parenteses_fecha): print('Expressão válida! ') else: print('Expressão inválida! ') Não desistam, dificuldades existem para que você possa lidar com um problema maior no futuro✌
Fiz dessa forma : expr = input('Digite uma expressão') abert = [] fech = [] for c in expr: if c == '(': abert.append(c) elif c == ')': fech.append(c) if len(abert) == len(fech): print('expressão correta') else: print('Expressão errada')
Primeiramente: PARABÉNS, Guanabara e equipe!!! Segundamente: Segue solução diferente, com comentários: import sys # Importação do sys para interromper a execução do programa em caso de "Expressão incorreta". expressao = "" posicao_abertura = [] # Lista com a posição dos parêntesis de abertura da expressão digitada posicao_fechamento = [] # Lista com a posição dos parêntesis de fechamento da expressão digitada expressao = (input('Digite uma expressão qualquer que use parêntesis: ')) for pos, caractere in enumerate(expressao): if caractere == '(': posicao_abertura.append(pos) # Acrescenta a posição do parêntesis de abertura à lista posicao_abertura elif caractere == ')': posicao_fechamento.append(pos) # Acrescenta a posição do parêntesis de fechamento à lista posicao_fechamento else: continue print(f'Expressão digitada: {"".join(expressao)}') # Imprime a expressão digitada if len(posicao_abertura) != len(posicao_fechamento): # Verifica se a quantidade de parêntesis de abertura é diferente da quantidade de fechamento print('Expressão incorreta (quantidade de parêntesis de abertura diferente dos de fechamento).') sys.exit() else: # Se a quantidade de parêntesis de abertura e de fechamento forem iguais, o código passa a verificar se estão em ordem correta posi = 0 while posi < len(posicao_abertura): decrescente = -1 if posicao_abertura[posi] < posicao_fechamento[decrescente]: # A linha acima compara se a posição do parêntesis de abertura (em ordem crescente da lista posicao_abertura) # é menor do que a posição do parêntesis de fechamento (em ordem decrescente da lista posicao_fechamento) decrescente -= 1 # Atualiza a variável "decrescente" posi += 1 # Atualiza a variável "posi" continue else: print('Expressão incorreta.') sys.exit() # Caso o programa não execute nenhum dos dois "sys.exit()" acima, a expressão estará correta: print('Expressão correta!!!') # Caso queira ver o conteúdo das listas posicao_abertura e posicao_fechamento, segue código abaixo: if len(posicao_abertura) >= 1: posicao_abertura.sort() print(f'Lista posicao_abertura: {", ".join(str(n) for n in posicao_abertura)}') if len(posicao_fechamento) >= 1: posicao_fechamento.sort() print(f'Lista posicao_fechamento: {", ".join(str(n) for n in posicao_fechamento)}')
A versão mais simples de todas (usando lista, pq também é possível fazer sem usar lista) que encontrei é assim... lista = [] expressao = str(input('Digite a expressão: ')) for i in range(0, len(expressao)): lista.append(expressao[i]) print('Sua expressão está correta!') if lista.count('(') == lista.count(')') else print('Sua expressão está errada!')
Usei o método count para resolver exp = str(input('Digite uma expressão: ')) lista = list(exp) if lista.count('(') == lista.count(')'): print('A expressão é válida') else: print('A expressão não é válida')
Tinha feito assim: e = input(' Digite a expressão: ') if e.count('(') == e.count(')'): print(' Sua expressão está válida!') else: print(' Sua expressão está errada!') Estava feliz em ter conseguido com poucas linhas, algo como "())( " daria como expressão válida.. 😅
se usar a lógica todo parentesis deve ser fechado em algum momento, dessa forma a expressao só é válida se o número de "( "e ")" for par, se for ímpar é porque algum parentesis nao foi fechado, usei essa logica no meu codigo: expressao = input('digite a expressão: ') contagem = expressao.count("(") + expressao.count(")") if contagem % 2 == 0: print('a expressao é válida') elif contagem == 0: print('isso não é uma expressao') else: print('a expressao não é válida')
expressao = [] exp = input("Digite uma expressão matemática com parênteses: ") expressao.append(exp) for expr in expressao: print(f"A expressão {expr}",end=' ') if expr.count('(') == expr.count(')') and exp[0]!=')': print("é uma operação válida") else: print("é uma operação inválida.") Pensei desse jeito. Não sei se atende as necessidades da lista, mas cumpre a função
Eu vi várias resoluções que apresentam uma possível resolução de uma forma mais simples, porém uma grande parte apresentava uma falha - não analisava as posições do mesmo. Consegui fazer de uma forma que não é tão "clean" quanto a do professo, mas resolvendo o problema para analisar as posições. expressão = list() expressão.append(input('Digite um expressão: ')) sige = sigd = posd = pose = ige = igd = 0 for exp in expressão: for pos, carac in enumerate(exp): if carac in '(': sigd += 1 posd = pos if carac in ')': sige += 1 pose = pos if sige == sigd: if posd < pose: ige += 1 igd += 1 if ige == igd and ige != 0 and igd != 0: print('Sua expressão está correta!') else: print('Sua expressão está incorreta.')
resolução: e = str(input('digite uma expressão(com parenteses):')) n = e.count('(') n1 = e.count(')') if n == n1: print('expressão valida') else: print('expressão invalida')
![CAMPปลิ้น | EP.83[2/2] ประสบการณ์ขนหัวลุกจากตำนานวงการผี!](http://i.ytimg.com/vi/T_kFecQw7Ds/mqdefault.jpg)
Estude pelo nosso site e tire certificado de 40 horas. Curso completo em:
www.cursoemvideo.com/curso/python-3-mundo-3/
Eu fiz através do comando 'count' que você já ensinou, acho que ficou melhor!! fiz assim:
expr = str(input('Digite a expressão: '))
if exp.count('(') == exp.count(')'):
print('Sua expressão é válida!!')
else:
print('Sua expressão não é válida')
Se estiver na ordem errada não vai detectar.
Exemplo: 6 + ) 85 (
@@Flaviormmv Código com bug arrumado:
.
.
.
expr = str(input('Digite a expressão: '))
pi = expr.count('(')
pf = expr.count(')')
if expr.index(')') > expr.index('('):
if pi == pf:
print('Expressão válida')
else:
print('Expressão é inválida')
else:
print('Expressão inválida')
@@ithallotulio Foi uma ótima ideia, mas ainda dá erro com expressões como esta (a*b)-)c(=12, porque o index vale apenas para a primeira aparição
@San D Erik nice
Ricardo Carvalho, pois é. Quando tiver a impressão de que produziu uma solução melhor, dê um passo atrás e avalie bem. A sua solução não funciona. Ex. "))) 3 + 1 ((( "seria aceito como válido!
Um salve pra quem também veio só dar like e agradecer o professor por mais um ótimo video!
Programador Sagaz q
eaeeee
Confesso que não consegui esse, mas vendo a resolução do Guanabara a gente abre a mente pra coisas novas, muito obrigado por compartilhar sua inteligencia e raciocínio conosco!!!
Também não consegui é meio chato quando a gente não consegue
@RuppFv kkkkkkkkkk
Paulera man, de explodi a mente, coisa linda, mesma coisa aqui kkkk.
Mano foi o primeiro exercicio desse curso que eu não consegui chegar numa solução, estou a mais de 1 semana nele pois costumo ver a correção só depois que consigo chegar numa solução mesmo com gambiarras kkk mas dessa vez não consegui :( Mas sim, abre muito a mente.
C@RALHOOOOOOOOOOOOOO, QUE GENIAL! Jamais teria pensado na solução sozinha, mas vendo a explicação do Guanabara foi muito esclarecedor. Que show!!!!!!!
Custei a entender a explicação. Tive que voltar trechos do vídeo várias vezes, e ainda assim não entendia. Depois de voltar trechos incontáveis vezes, ler comentários dos colegas e assistir o vídeo completo pela segunda vez, na velocidade 0.75x, só então consegui entender o raciocínio e a explicação. Digo isso pq, muitos, assim como eu, podem ter tido dificuldade para entender o exercício, mesmo com a explicação do professor, e terem se sentido burros por isso (como eu me senti por um momento kkkk). Mas é questão de persistência, gente! Assiste quantas vezes for necessário, volta os trechos 500 vezes, se precisar colocar o vídeo na velocidade mais lenta que tiver, coloque, mas não desista. Uma hora a gente entende! kkkk
Valeu, Guanabara, por esse curso super completo feito com muito carinho e dedicação para nós!
Até o momento achei o exercicio mais dificil, porém, conforme vc vê a explicação fica claro. Doidera.
@@FabianoZonta Acho que ele deu uma complicada na resolução , achei esse exercício MUITO fácil .
Pra mim o exercício mais difícil foi o de fazer uma lista ordenada sem utilizar o sorted kkkkk
Eu sou um desses que está com dificuldade no exercício
@@Luan-ev1kk pra mim tbm, O guanabara fez um bglh mega complexo pra uma solução bem simples, era só usar o count() e o find() que ja resolvia tudo em 5 linhas.
O unico exercicio que n consegui fazer foi aquela lá sem utilizar o Sort() e nem entendi a explicação prefiri passar pra proxima pra eu n fritar minha cabeça
tem umas que a pessoa vai melhor e outras que vai pior, normal isso, todo desenhista comeca fazendo desenho feio
Fique um tempo tentando entender o que isso tinha haver com listas, mas não descobri até o Guanabara falar no começo do vídeo.
Eu fiz muito diferente. A minha lógica era contar se a quantidade de "(" era igual a quantidade de ")". Pra isso era só usar o método count para cada item e comparar. Só deu 5 linhas de código. Segue abaixo o código.
expr = str(input('Digite sua expressão: '))
if expr.count('(') == expr.count(')'):
print('Sua expressão é válida')
else:
print('Sua expressão não é válida')
Sei que já tem um tempo... na verdade tem um pequeno problema, em nenhuma porção da expressao pode ter mais fecha do que abre parenteses. ") a + b ( " tem o mesmo numero de abre e fecha, mas está incorreta.
#segue parte do meu codigo
expressao = "(1 + 1 * (50 / ()(23 - 2))"
abre = 0
fecha = 0
correto = True
for l in expressao:
if l == '(':
abre += 1
elif l == ')':
fecha += 1
if fecha > abre:
correto = False
break
correto = (abre == fecha) and correto
@@tviegasf o código do Guanabara está correto, se você digitar ") a + b (" vai dar expressão inválida, pois assim que o ")" cair no laço com a pilha vazia já vai dar um break.
@@ctcred8642 eu me referia ao código do Igor, que apenas conta o número de ) e (. O do Guanabara eu sei que está certo.
@@tviegasf Pode explicar essa expressão sua pf? pq tem um parênteses vazio? n estaria faltando um parênteses no final?
Para mim o exercício mais difícil foi o de colocar em ordem sem o sort(), colocando os valores no meio.
Mas vamos com foco e fé que vamos conseguir
Se for o 70, foi o único que eu não fiz. Queria fazer com listas, mas não sabia ainda, então está guardado para o grand finale. kkkk
@@AlexLogica kkk nada melhor do que um grande final
@@AlexLogica eu fiz com dicionário kkkkkkkkkkkkkkkk
@@AlexLogica linha = ('-=') * 10
preço = totmil = mais_barato = 0
continuar = 'S'
barato_nome = ''
produtos = {
1: {'nome': 'RTX 4090', 'preco': 14000},
2: {'nome': 'PS5', 'preco': 5000},
3: {'nome': 'teclado RAZER', 'preco': 650},
4: {'nome': 'cadeira gamer', 'preco': 1300}
}
print(f'{linha}LOJA BARATÃO{linha}')
print('produtos disponíveis: ')
for key, value in produtos.items():
print(f"{value['nome']}: {value['preco']} R$ [{key}]")
while True:
carrinho = int(input('quais produtos você quer levar? '))
if carrinho in produtos:
preço += produtos[carrinho]['preco']
if produtos[carrinho]['preco'] < mais_barato or mais_barato == 0:
mais_barato = produtos[carrinho]['preco']
barato_nome = produtos[carrinho]['nome']
if produtos[carrinho]['preco'] > 1000:
totmil += 1
else:
print('produto não encontrado, tente novamente. ')
continuar = str(input('quer continuar? [S/N}')).upper().strip()
while continuar not in ['N', 'S']:
print('opção inválida, tente novamente')
continuar = str(input('quer continuar? [S/N}')).upper().strip()
if continuar == 'N':
break
print(f'preço total: {preço} R$')
print(f'temos {totmil} produtos acima de 1000 R$')
print(f'o produto mais barato é {barato_nome} por {mais_barato}R$')
print('Fim')
Sem sombra de duvidas, vou refazer esse curso umas 2 vezes.
"Você nunca vai aprender a programar assistindo um vídeo chamado, "Aprenda a programar". E todo mundo que eu conheço e que programa bem aprenderam todos da mesma forma. Eles tem uma ideia e tentam replicar em forma de código, ou seja, aprendem programando. Então o único conselho que eu tenho para quem quer aprender a programar é, VÁ PROGRAMAR!" - George Hotz (Simplesmente o cara que desenvolveu a própria IA de carros autônomos)
@@luizfernandozacarkimsoares110 Melhor resposta encontrada nesse video!
expressao = str(input('Digite sua espressao: '))
aberto = expressao.count('(')
fechado = expressao.count(')')
if aberto != fechado:
print('Expressão INVÁLIDA...')
else:
print('Expressão VÁLIDA...')
fiz dessa forma achei muito simples nao sei se é totalmente correta, mas funciona bem.
Eu fiz assim, da errado pq se vc colocar )a + b( ele valida
@@lucasmisael7507 é só colocar uma condição, que se o índice zero da sua lista fatiada(strip()) for igual a ")" então a expressão é invalida.
Em pleno 2021, curso ainda é o melhor =)
resolvi de maneira diferente...
a = str(input(' Digite a expressão: '))
paberto = 0
pfechado = 0
for simb in a:
if simb == '(':
paberto += 1
elif simb == ')':
pfechado += 1
if paberto == pfechado:
print(f' Sua expressão está certa.')
else:
print(f' Sua expressão está incorreta.')
resolvi da mesma maneira
também pensei em resolver o problema assim, mas achei que iria ficar gambiarra, então preferi ver a resolução antes
Segui uma lógica semelhante, mas de forma diferente. Fiz uma lista apenas com os parênteses e depois analisei.
Ficou um pouco mais longo mas fiquei feliz de ter conseguido sozinho!
# DESAFIO 083
expressao = (input('Digite uma expressão matemática: '))
lista = []
for i in expressao:
if i == '(' or i ==')':
lista.append(i)
check = 0
for j in lista:
if j == '(':
check += 1
elif j == ')':
check -= 1
if check < 0:
break
if check == 0:
print('Expressão CORRETA!')
else:
print('Expressão ERRADA!')
caramba, perfeito, bem intuitivo, ótima linha de raciocínio!
Cara custei pra entender isso, estava me sentindo uma merda por que eu não estava de jeito nenhum entendendo, chegou um momento que pensei até em desistir, mas eu persisti muito e consegui entender… não desista galera, persista que uma hora a gente consegue.
Tanbém passei por isso.
Mas estamos aqui, sempre olhando para frente.
Depois de umas horas analisando o código, entendi essa bagassa. Meu amigo como demorei entender isso, tá não foi muito, cerca de 2 horas, mas no espaço tempo dependendo do seu estado de consciência e foco, parecem 4 ou 6 horas. Mas enfim.
EXPLICAÇÃO DO CÓDIGO
ELE LER CADA CARCATERE DA EXPRESSÂO
SE FOR UM CARACTERE ( ABERTO
ELE ADICIONA A LISTA (VAI ADICIONANDO OS QUE ACHA)
SE FOR UM ) FECHADO
ELE VERIFICA SE O TAMANHO DA LISTA É > 0, SE FOR, ELE REMOVE O ÚTIMO CARACTERE DA LISTA
SE A LISTA NAO FOR MAIOR QUE 0 OU SEJA, NÃO TEM UM ABERTO (, ELE ADICIONA UM )FECHADO E O TAMANHO DA LISTA PASSA A VALER zer0
SE A LISTA TIVER SÓ 1 CARACTERE ( ou ), A EXPRESSÃO ESTAR CORRETA
SENÃO A EXPRESSÃO ESTÁ ERRADA
EX EXPRESSÃO CORRETA NA LISTA:
DIGITAMOS ((2+1))
É ARMAZENADO NA LISTA (( ))
MAS O SEGREDO É QUE O QUE ME CONFUDIO FOI PENSAR QUE A LISTA AUMENTA DE TAMANHO, MAS NA VERDADE A CADA CARACTERE ADICIONADO NELA, O ANTERIOR É REMOVIDO, E O TAMANHO DELA É SEMPRE 0 QUANDO ESTÁ NA ORDEM CORRE DE PARÊNTESES.
QUANDO ELE ENCONTRA UM ABERTO ( ELE ADICIONA A LISTA, APOS ENCONTRAR OUTRO A LISTA AUMENTA E FICA MAIRO QUE ZER0, FICANDO ASSIM
( (
0 1
MAS TODA VEZ QUE A LISTA FICA MAIOR QUE ZERO, ELE APAGA ESSE ULTIMO VALOR DA LISTA COM O MÉTODO POP, CRIANDO ESSA ANIMAÇÃO QUE ENTENDI MENTALMENTE:
( ( ENCONTROU MAIS OUTRO ABERTO
0 1
( E APAGA ELE
0
( ( ENCONTROU MAIS OUTRO ABERTO
0 1
( E APAGA ELE
0
TODA VEZ QUE ELE ENCONTRA UM (, ELE APAGA E O COMPRIMENTO DA LISTA FICA SEMPRE ZER0
TODA VEZ QUE ELE ENCONTRA UM ) FECHADO NA EXPRESSÂO
ELE APAGA O ( ABERTO DA ULTIMA POSIÇÃO
EXEMPLO
( ( ) )
ELE ARMAZENA 2 ( ( ABERTOS NA LISTA E ENCONTRA 2 ) FECHADO NA EXPRESSÃO
TODA VEZ, PRESTA ATENÇÃO, TODA VEZ QUE ELE ENCONTRA UM FECHADO ) NA EXPRESSÃO
ELE APAGA O ULTIMO ( ABERTO ARMAZENADO NA LISTA COM O MÉTODO .pop()
CRIANDO A ANIMAÇÃO QUE CITEI ANTERIORMENTE
SE NÃO, COMO A LISTA ESTARA VAZIA APOS APAGAR OS PARENTESES ( ABERTOS COM OS PARENTESES )FECHADOS DE ACORDO COM A QUANTIDADE PROPORCIONAL, ELE ADICIONA O PARENTESES ) ABERTO DA EXPRESSÃO PRA LISTA PASSAR A VALER ZER0
LISTA == 0
NA EXPRESSÃO
if len(lista) > 0:
lista.pop()
else:
lista.append(')')
break
DIZ QUE SE O TAMANHO DA LISTA FOR > 0, ELE APAGA OS (
MAS AI QUE TEM OUTRO SEGREDO
EXISTEM 3 POSSIBILIDADES:
1 NORAML:
((( ))) ENCONTRAR NA LISTA O TAMANHO PROPORCIONAL DE ( A SER APAGADO, TEM 3, APAGA 3 E A LISTA VALE VAZIO
MAS COMO REGRA, COMO A LISTA NÃO É MAIOR QUE ZERO, É ADICIONADO O PARENTESES )FECHADO E ELA PASSA A QUE PASSA A VALER ZER0 AGORA
2 DESPROPORCIONAL:
(( ) APAGA APENAS 1 (ABERTO POR QUE SÓ TEM 1 FECHADO, A LISTA REALMENTE NÃO É MAIOR QUE ZERO, MAS SE ELA NAO FOR, ELE ADICIONA O ) FECHADO NA LISTA, FAZENDO COM QUE O VALOR PASSE A VALER 1, POR CONTA DISSO A EXPRESSÃO ESTÁ ERRADA
3 POSSIBILIDADE:
SUPONHAMOS QUE VOCÊ TENHA DIGITADO ( ) ), O ( SERA APAGADO PELO PRIMEIRO ), E A LISTA APASSARA A SER VAZIA. VAZIO NÃO É UM VALOR, ENTÃO ELE NAO PODE SER DITO COMO MAIOR QUE ZERO, PORTANTO A ADIÇÃO DO PARENTESES ) FECHADO É IGNORADO PELO PROGRAMA, E A LISTA PASSA A NÃO TER NENHUM VALOR, O QUE TORNA A EXPRESSÂO CORRETA.
A EXPRESSÂO SÓ SERÁ ACEITA SE O VALOR FOR == 0
Eu fiz um pouquinho diferente:
lista = []
ex = str(input('Digite a expressão: '))
for p in ex:
if p == '(' or p == ')':
lista.append(p)
if lista.count('(') == lista.count(')'):
print('Sua expressão está correta!')
else:
print('Sua expressão está errada!')
Muito obrigado pelo aprendizado, professor! A dissecação que o Sr faz nos exercícios é sempre muito importante!
essa sua dá válido quando digita, por exemplo, )a + b(
#fiz por meio de uma variável em strg
aberto = fechado = 0
c = 0
while True:
expressao = str(input('Digite a expressão: ')).strip()
while c < len(expressao):
if '(' in expressao[c]:
aberto += 1
if ')' in expressao[c]:
fechado += 1
c += 1
if aberto == fechado:
print(f'Sua expressão {expressao} é valida')
Estou no meio do curso de "MySQL", vim aqui avisar (07/2018) que são 600K de inscritos. Cara ótimo canal, espero que chegue em 1M logo. Terminei um curso em tecnologia e só comecei a gostar de programação quando esse canal apareceu na minha vida. Já é o 3° curso que faço, iniciei desde março desse ano. Parabéns a toda equipe e ao professor sensacional.
Acertou! O canal já tá com 1,16 milhões de inscritos
@@ajcs9574 1.31M,agora
1,37m
1/4/2021
1,63m
como está hj em dia parceiro?
muito boa essa lógica, não estava conseguindo entender como comparar os parenteses.
Mais uma aula soberba de resolução de exercícios do Prof. Guanabara. Me fez sentir que tenho uma longa estrada pela frente para dominar vários aspectos da Linguagem Python. Sou novo em programação, apesar dos meus já 42 anos, e talvez por um aspecto pessoal me atenho mais a semântica de um problema. Os vários métodos, classes, tipos primitivos, tipos de variáveis e bibliotecas do Python me faz sentir um artesão. Na verdade estou convicto que programar é uma arte. Não há um único modo de fazer as coisas, de resolver problemas, de programar e criar soluções. Talvez a arte da programação seja o ápice da criatividade humana. Gosto muito de usar variáveis em códigos do Python. Quanto mais simples for a solução encontrada por mim, mais satisfeito fico com a arte "printada", risos!!!. Alguém poderia me explicar em linguagem simples o que é um vetor em programação? Sei um pouco sobre o assunto quando estudei em Álgebra Linear, e na Física Newtoniana, mas parei por aí. Abaixo segue minha simplória solução do problema. Abraços a todos do Curso em Vídeo.
lista = []
a = '('
b = ')'
n1 = 0
n2 = 0
lista = str(input('Digite a expressão: ')).strip()
if (a in lista) and (b in lista):
n1 = lista.count(a)
n2 = lista.count(b)
if n1 == n2:
print('Sua expressão está correta!')
else:
print('Sua expressão está errada!')
Fiz de uma forma diferente e foi muito bom bater minha cabeça pra conseguir fazer dar certo. Aprendi muita coisa fazendo esse código. Além da funcionalidade básica de verificar se a expressão está certa ele também consegue corrigir algumas expressões como: )4-3( * 2 + )45-5( * (23-2)
Se quiser pode testar algumas expressões, o código corrige o erro ")(" . No momento não sei se vou atualizar o código pra corrigir mais erros:
from time import sleep
expression = input('Digite sua expressão: ')
verification = (expression.count('(') == expression.count(')'))
erro = ''
pos = []
pos_fecha = []
pos_new = []
for w,x in enumerate(expression):
if x == '(':
pos.append(w)
print(pos) #
for k,l in enumerate(expression):
if l == ')':
pos_fecha.append(k)
print(pos_fecha) #
for c,b in zip(pos,pos_fecha):
find_fecha = expression.find(')', b)
find_abre = expression.find('(', c)
print(f'{find_fecha} > {find_abre}') #
if find_fecha < find_abre:
print('Não está valido') #
erro = 'sim'
pos_new.append(c)
pos_new.append(b)
else:
print('Valida') #
pass
rangepos = int(len(pos_new)/2)
n = 0
if erro == 'sim':
exp_new = list(expression)
for c in range(rangepos):
exp_new[pos_new[c+n]] = exp_new[pos_new[c+n+1]]
exp_new[pos_new[c+n+1]] = '('
n = n + 1
exp_new = (''.join(exp_new))
print(f'
Sua expressão está errada! O certo seria {exp_new}')
else:
print('
Sua expressão passou no primeiro teste, agora vamos para o segundo:
')
print('...
')
sleep(2)
if expression.count('(') == expression.count(')'):
print('
Sua expressão passou no teste. Ela é válida!')
else:
print('Sua expressão não passou do segundo teste e está errada!')
# as linhas com comentários foram usadas como debug
Minha solução ficou mais curta, assim:
n = (str(input('
Digite sua expressão: ')))
aberto = 0
fechado = 0
for c in n:
if c == '(':
aberto += 1
if c == ')':
fechado += 1
if aberto == fechado:
print('
Sua expressão está correta')
else:
print('
Sua expressão está errada')
Muito obg por estar me ajudando a entrar nesse mundo da programação, eu só consigo entender se explicarem com 'objetividade e clareza' e vc faz isso muuuuuuito bem, parabéns
obrigadooooo so entendi com o seu
Tava fazendo praticamente a mesma coisa, mas percebi uma falha.
O código não dá inválido se "fechar" a expressão com ')' antes de ter aberto com '(', só tá contando se o número dos dois bate. Então a expressão:
)3(3+3()
Tá dando que está correto.
obs : depois de 3 anos tu com certeza já deve saber desse problema, mas resolvi comentar para as pessoas que cometer o mesmo erro que nós.
esse é o primeiro canal que dou like antes mesmo de assistir o conteúdo pois tenho certeza que será bom e não quero esquecer de curtir de forma alguma. Parabéns professor! Você é uma inspiração!
Excelente para aprender a lógica. Outra solução sem utilizar a lógica que o professor pretendeu mostrar, mas ainda usando apenas o que foi aprendido até agora seria:
expressão = str(input('Digite a expressão: '))
if expressão.count('(') == expressão.count(')'):
print('Sua expressão é válida!')
else:
print('Sua expressão é inválida!')
Abraços
Sua solução tem um problema. Por exemplo, se eu digitar uma expressão assim: a+b)*(c+d
Seu programa dirá que está correto.
Você tem razão Ewerton, mas é compatível com a fase que se encontra no curso e com a proposta do exercício. Você não acha que se formos muito além disso estaríamos mostrando algo que ainda não foi abordado e poderíamos confundir os iniciantes? Não vi a sua sugestão de solução aqui amigo. Compartilhe conosco. Aqui vai uma outra versão que é um pouco melhor mas continua com problemas pois a expressão a+b)*(c+d já não passa, mas a+b(*)c+d passa. Salientom que nãom usei listas pois não foi visto ainda nesta fase do curso. Abraço.
expressão = str(input('Digite a expressão: '))
parentesis = ''
for elemento in expressão:
if elemento in '()':
parentesis += elemento
if parentesis[0] == '(' and parentesis[-1] == ')':
if expressão.count('(') == expressão.count(')'):
print('Sua expressão é válida!')
else:
print('Sua expressão é inválida!')
@@LisandroGuerra A solução mais viável é a apresentada no vídeo
Acaso deveria ser a minha? Acho que não. Aqui vai uma outra versão que é um pouco melhor mas continua com problemas pois a expressão a+b)*(c+d já não passa, mas a+b(*)c+d passa. Saliento que não usei listas pois não foi visto ainda nesta fase do curso (Correção: tem listas sim nesta fase, mas fica como exemplo de como fazer com string). Muito obrigado ao amigo pelo retorno e caso veja algum erro nesta versão sinta-se à vontade para falar. Abraço
expressão = str(input('Digite a expressão: '))
parentesis = ''
for elemento in expressão:
if elemento in '()':
parentesis += elemento
if parentesis[0] == '(' and parentesis[-1] == ')':
if expressão.count('(') == expressão.count(')'):
print('Sua expressão é válida!')
else:
print('Sua expressão é inválida!')
Realmente você tem razão em dizer que continua com problemas, pois nesse a expressão a*(b+c) que está correta é dada como errada. Sei que você quer melhorar seu código, e não digo que você está errado, mas ao meu ver, não consigo imaginar solução melhor que a do Guanabara, porque ela analisa elemento por elemento dentro de um laço, o que a torna a prova de falhas, se ')' é digitado antes de '(' é executado uma quebra de laço(break), e a expressão é dada como inválida imediatamente, caso contrário ela analisa até o último elemento verificando a quantidade de colchetes e só então a expressão é validada caso possua a mesma quantidade de parênteses que fecham e que abrem.
Muito bom esse exercício.
Achei que minha solução estava certa, mas depois que vi a correção percebi que daria erro se eu colocasse um parêntese fechando antes do primeiro abrindo.
ex:
)a+b(
Na minha solução teria dado como certo quando na verdade está errado.
A minha também...
Pois só checava se a quantidade de aberto era a mesma de fechado...
Não verificava a ordem...
X(
Primeiramente, meu muito obrigado ao Guanabara e a todos os apoiadores por este excelente curso! Sério, a didática é MUITO BOA! Achei a solução do Guanabara para este exercício bem elegante a penso que vai ser bem útil essa ideia de adicionar da lista e remover da mesma para saber se as quantidades são equivalentes. Como vi nos comentários que tinha muita gente pensando para entender a solução dele, resolvi compartilhar a minha que eu acredito ser bem mais fácil de entender. Apenas adicionei os parenteses abertos a uma lista e os fechados à outra lista. Depois comparei o tamanho de ambas essas listas com len(). Se os tamanhos forem diferentes, significa que o número de parenteses fechando ou abrindo não é o mesmo e portanto a expressao é inválida. Se tiver o mesmo número de parenteses fechando e abrindo, a expresão é valida. Por que no final é isso que vai importar, não é mesmo? Se tem 6 parenteses abrindo, vai precisar ter 6 fechando. Se tem 4 abrindo e somente 3 fechando, vai ser inválida, pois falta 1 parenteses fechando.
Minha solução:
lista = []
lista_aberto = []
lista_fechado = []
expressão = str(input('Digite a expressão:'))
for str in expressão:
lista.append(str) #esta parte aqui do lista.append(str) não é relevante para o exercício. Coloquei somente para ter a lista toda. Não precisa ter esta parte.
#separa em uma lista os parenteses abertos
if str == '(':
lista_aberto.append(str)
#separa em outra lista os parenteses fechados
elif str == ')':
lista_fechado.append(str)
#Compara o tamanho de ambas as listas -> parenteses abertos x parenteses fechados
if len(lista_aberto) == len(lista_fechado):
print('Expressão válida.')
else:
print('Expressão inválida.')
Ótima aula, Guanabara! Eu fiz utilizando uma variável que conta a quantidade de parênteses e, se a quantidade for PAR, significa que é uma expressão válida:
expressao = str(input('Digite uma expressão com parênteses: '))
quantidade_parenteses = 0
for indice, valor in enumerate(expressao):
if valor in '(' or valor in ')':
quantidade_parenteses += 1
if quantidade_parenteses % 2 == 0:
print('Sua expressão é VÁLIDA.')
else:
print('Sua expressão é INVÁLIDA. Verifique a ordem e quantidade dos parênteses.')
caralho, genio demais
Também tentei assim, mas ela têm um erro.
Se a expressão for:
(((a+b)*c por exemplo, você tem 4 parenteses, só que ainda assim está incorreta.
O que eu fiz foi, botar cada '(' ')' em uma variável para contar a quantidade e caso as 2 variáveis tenham o mesmo número, ai sim ela está correta
no caso:
frase = str(input('Digite a expressão: '))
n_parenteses1 = frase.count('(')
n_parenteses2 = frase.count(')')
if frase[0] in ')':
print('Sua expressão está incorreta!!')
elif n_parenteses1 == n_parenteses2:
print('Sua expressão está válida!')
else:
print('Sua expressão está incorreta!!')
@@lucasdomingues1438 se a expressao for assim (a+b) (a + c(c-b( ))) vai dar valido mas no caso seria invalido, nao?
Meu raciocínio foi bem parecido,mas acho que ficou mais simples de entender...
lista = list(input('Digite a sua equação, meu caro ser humano! '))
c1 = 0
for c in lista:
if c == '(':
c1 += 1
if c == ')':
c1 -= 1
if c1 < 0:
break
if c1 != 0:
print('A equação não está correta!')
if c1 == 0:
print('A equação está correta!')
ai sim entendi
"if c1 < 0:
break"
Eu não entendi bem o pq do 'break'. Ele é necessário pra fazer o laço parar? Na minha resolução, eu não coloquei. Não bastaria apenas as linhas:
"if c1 != 0:
print('A equação não está correta!')"?
Eu só contei se o número de parenteses é par. Pra que todos estejam fechados corretamente, o número obrigatoriamente TEM que ser PAR. Então eu verifiquei se a quantidade de parenteses era par e funcionou direitinho. Segue o código:
expressao = input("Digite uma expressão matemática qualquier: ")
parentesesAbrindo = "("
parentesesFechando = ")"
contaParenteses = expressao.count(parentesesAbrindo) + expressao.count(parentesesFechando)
if contaParenteses % 2 != 0:
print("Expressão inválida.")
else:
print("Expressão válida.")
Opa, mas assim dá errado, pq se você tiver 3 parênteses abrindo e um só fechando tipo assim ((a+b)+3*(4+5
essa expressao é inválida, mas seu código irá dizer que é válida, já que o número de parênteses é par.
Você precisar ver se o número de parênteses abrindo + os fechando é par. Aí sim, daria certo. Forte abraço!
obs.: a pilha é uma estrutura em que o último que entra é o primeiro que sai.
Resumindo a explicação do vídeo:
percorre a lista (expr) com for ( for simb in expr )
- se achar parêntese abrindo ( if simb == '(' ), armazena na pilha ( pilha.append('(') );
- se achar parêntese fechando ( if simb == ')' ), remove da pilha ( pilha.pop() ). *
ao final, se pilha vazia ( len(pilha) ==0 ), expressão validada; caso contrário, expressão inválida.
Cara, eu procuro sempre simplificar minhas soluções. Antes de ver a correção, pensei:
Todo abre parênteses '(' precisa de um fecha parênteses ')', portanto parênteses é uma dupla de simbolos.
meu código ficou assim:
exp = input('Digite a expressão entre parenteses: ')
parenteses_abre = []
parenteses_fecha = []
for caractere in exp:
if caractere == '(':
parenteses_abre.append('(')
elif caractere == ')':
parenteses_fecha.append(')')
soma_parenteses = len(parenteses_abre) + len(parenteses_fecha)
if soma_parenteses % 2 == 0:
print('Expressão Válida!')
else:
print('Expressão invalida')
Acredito piamente que não seja a solução mais efetiva, mas resolve o problema proposto.
@@rodrigoasafh1500 obrigado por compartilhar. Você tem a filosofia certa: entregar a solução mais simples que funcione. Depois vc refatora e vê o que pode melhorar. Sobre a solução apresentada, acho que fiz algo assim, mas lembro que se colocasse número par de parênteses abrindo somente, o código daria "expressão válida", mesmo não tendo os parênteses fechando. Na minha opinião esse é um dos desafios mais difíceis de desenvolver uma solução à prova de usuário. Abraço!
@@rodrigoasafh1500opa, tudo bem? Eu fiz muito parecido com você, mas sua solução pode dar um problema se houver número pares tanto de '(' quanto ')'. Eu solucionei isso comparando o tamanho das listas.
If len(lista 1) == len(lista2):
Print('operação valida')
Else:
Print('operacao invalida')
Desse modo, se a lista que possuir o "(" for do mesmo tamanho que a lista que possuir o ")", a operação tá valida. Desculpa qualquer erro de digitação, tô no celular 😅
Fiz de outro jeito e deu certo também. Contei o número de parênteses abrindo e o número fechando, aí fiz a comparação entre eles. Se fosse igual estava certo, caso contrário estava errado.
A minha foi similar à do 'Ricardo Carvalho', que comentou acima. Usei a função 'count()' para verificar se o número de parênteses abrindo tem o mesmo número dos parênteses fechando.
lista = list()
expressao = str(input('Digite a expressão: '))
for n in range(0,len(expressao)):
lista.append(expressao[n])
print(lista)
pAberto = lista.count('(')
pFechado = lista.count(')')
if pAberto == pFechado:
print('Sua expressão está válida!')
else:
print('Sua expressão está inválida!')
Eu geralmente gosto de ver os comentários para ver outras resoluções, então vou deixar a minha, já que é bem diferente do professor.
lista = list(str(input('Digite um expressão: ')))
x = 0
for c in lista:
if c == '(':
x += 1
if c == ')':
x -= 1
if x < 0:
break
if x == 0:
print('A expressão está correta!!')
else:
print('Sua expressão está errada!')
usei a mesma ideia do contador, mas menos simples que isso haha
Genial, me fez lembrar epoca da facul construindo pilhas em LFA
Vim agradecer pelo conteúdo! Minha solução pra esse exercício foi esta:
count = 0
expressao = str(input('Digite uma expressão matemática envolvida em parênteses: '))
for v in expressao:
if v == '(' or v == ')':
count += 1
if count % 2 == 0:
print(f'A expressão {expressao} está correta!')
else:
print(f'A expressão {expressao} não está correta!')
Cheguei nesse resultado, gostei mt dele, por ter economizado linhas:
exp = (input('Digite uma expressão utilizando parênteses: '))
tot = exp.count('(') + exp.count(')')
if tot % 2 != 0 or exp.count('(') != exp.count(')'):
print('Expressão inválida!')
else:
print('Expressão válida!')
Eu fiz assim:
lista1 = []
lista2 = []
e = input('expressão: ')
for c in e:
if c == '(':
lista1.append(c)
elif c == ')':
lista2.append(c)
if len(lista1) == len(lista2):
print('Expressão correta')
else:
print('Expressão errada')
Eu tbm
@Felipe Rocha me dá um exemplo
No início é difícil mas só por a cbç pra funcionar e usar a lógica dentro da expressão:
exp = input('
Digite a expressão matemática: ')
pa = 0
pf = 0
for a in list(exp):
if a == '(':
pa += 1
if a == ')':
pf += 1
if pa == pf:
print('Expessão válida!')
else:
print('Expressão inválida!')
Eu fiz a mesma lógica que você hahahaha só que utilizei apenas uma variável contadora, eu vou somando e subtraindo nela e depois verifico se ela é igual a 0. Deve estar certo né hahaha
Boa noite, eu não consegui pensar em nada diferente quando eu fiz esse exercício.Porque estaria errado?
@@Ulusamay Diga aí
@@bugatess manda ae tbm se puder
Se quiser eu mando, mas eu não usei lista que nem o Guanabara. Eu sei que o intuito da aula era usar listas, mas eu preferi usar o vetor mesmo, o resultado é o mesmo, e acho até mais fácil de entender. Se quiser eu posso mandar. Quanto ao amigo do comentário acima, eu realmente encontrei erro no código, eu basicamente validava com base no número de vezes que o usuário digitava '(' ou ')'. O problema era se o usuário abria e fechava na mesma quantidade mas fechava primeiro, como por exemplo, "a + b) + c(". Acabei de consertar. Se quiserem o código eu compartilho, mas como disse acima, não usei lista. :(
Consegui de uma maneira que eu achei simples ....
role para baixo hehehe
expr = str(input("Digite uma expressão:"))
pilha = 0
for cont in expr:
if cont == "(":
pilha += 1
if cont == ")":
pilha -= 1
if pilha < 0:
break
if pilha == 0:
print("Sua expressão é valida!!!")
else:
print("Sua expressão é invalida!!!")
Vim aqui pra postar essa solução, fiz igualzinho! o/
Também fiz assim. Realmente é muito mais símples. Parabéns.
Adorei!
é uma boa, mas nao teria obrigatoriamente que usar listas( [ ] )?
Parabéns pela resolução. O que não entendi é como o código reconhece que essa expressão ))) 8 + 5 ((( está errada. Pelo o que to vendo o código só leva em consideração a quantidade de parenteses e não a posição. Nesse caso a PILHA fica em 0, mas ele deu como expressão invalida.
x = input(print("Digite a expressão:"))
y = 0
cont = 0
cont2 = 0
while y < len(x):
if x[y] == "(":
cont += 1
if x[y] == ")":
cont2 += 1
y += 1
if cont == cont2:
print("Correto")
else:
print("Errado")
Tb fiz assim cara, bem mais facil do que a solução do professor
Fiz esse exercício utilizando o método '.count' e achei que ficou mais fácil:
expressão = list(str(input('Digite uma expressão matemática: ')))
if expressão.count('(') == expressão.count(')'):
print(f'A expressão é válida')
else:
print(f'A expressão é inválida')
Fiz com um algoritmo diferente, porém chegando ao mesmo resultado :) Para quem quiser ver outra forma de fazer, eis o código:
expressao = str(input('Digite a expressão com parênteses: '))
parentesesabertos = list()
parentesesfechados = list()
for c in expressao:
if c == '(':
parentesesabertos.append(c)
elif c == ')':
parentesesfechados.append(c)
if len(parentesesabertos) == len(parentesesfechados):
print(f'A expressão está correta! Você abriu e fechou {len(parentesesabertos)} parênteses.')
else:
print(f'A expressão está incorreta! Você abriu {len(parentesesabertos)} parênteses, '
f'porém fechou {len(parentesesfechados)}.')
Fiz igual! Muito interessante saber que fazer coisas completamente diferentes chegam no mesmo resultado!
mas se for ())) ((() da certo tb, o que seria um erro
Fiz bem diferente do vídeo, apenas manipulando a string e if's.
Segue o código :
e = str(input("Digite sua expressão :")).strip()
p1 = e.count("(")
p2 = e.count(")")
if p1 == p2:
print("Sua expressão está correta !")
else:
print("Sua expressão está incorreta !")
Guilherme Matos Passarini Até pensei nesta possibilidade, mas agora me diga uma expressão que se encontra nesse caso. Não consiguir imaginar.
Ex:(a+(b*c)+d)
Não deixa de estar correta por exemplo.
esta incompleta a sua solução
Guilherme Matos Passarini Isso se resolve apenas colocando uma condição a mais.
if expr[0] == '(' and expr[-1] == ')':
Arthur show de bola sua solução, vou lhe confessar que eu não consegui resolver mas olhando para sua logica ficou simples e fácil de entender.
não nescessariamente poderia esta assim a)b + a()( ainda continuaria incompleto, alem disso deve usar o while já que ele pediu pra ir digitando ilimitadamente
Melhorei esse desafio e ele reconhece erros de expressão como (x+), (x + 2)(x - 1) ou até (x + 3)/.
Vale lembrar que para um computador, entre um parêntesis e outro sempre deve haver um operador.
Deu bastante trabalho mas valeu a pena.
while True:
expressao = str(input('\033[33mDigite uma expressão: ')).replace(' ', '')
erro = parentesis_esquerda = parentesis_direita = 0
lista_operadores = ['+', '-', '/', '*', '^']
for p in expressao:
if p in '(':
parentesis_esquerda += 1
if p in ')':
parentesis_direita += 1
if parentesis_direita != parentesis_esquerda:
print('\033[31mERRO1: A quantidade de parêntesis não é a mesma. FALTAM PARÊNTESIS')
erro = 1
for n in range(0, 10):
if f'){n}' in expressao:
print('\033[31mERRO2: Existe um parêntesis incorreto à esquerda de um número. FALTA OPERADOR')
erro = 2
if f'{n}(' in expressao:
print('\033[31mERRO3: Existe um parêntesis incorreto à direita de um número. FALTA OPERADOR')
erro = 3
for o in lista_operadores:
if f'({o}' in expressao:
print('\033[31mERRO4: Existe um parêntesis incorreto à esquerda de um operador. FALTA NÚMERO OU INCÓGNITA')
erro = 4
if f'{o})' in expressao:
print('\033[31mERRO5: Existe um parêntesis incorreto à direita de um operador. FALTA NÚMERO OU INCÓGNITA')
erro = 5
if expressao[-1] in lista_operadores:
print('\033[31mERRO6: A expressão termina com operadores. FALTA NÚMERO OU INCÓGNITA')
erro = 6
if expressao[0] in lista_operadores:
print('\033[31mERRO7: A expressão começa com operadores. FALTA NÚMERO OU INCÓGNITA')
erro = 7
if '()' in expressao:
print('\033[31mERRO8: A expressão contém parêntesis se encostando. FALTA NÚMERO OU INCÓGNITA')
erro = 8
if ')(' in expressao:
print('\033[31mERRO9: A expressão contém parêntesis se encostando. FALTA OPERADOR')
erro = 9
if erro == 0:
print('\033[35mA expressão digitada está correta.')
print(10 * '\033[34m-=-')
continuar = str(input('\033[33mDeseja digitar uma nova expressão? [S/N]: ')).strip().upper()[0]
if continuar == 'N':
print('\033[34mOBRIGADO POR UTILIZAR O PROGRAMA!')
break
print(10 * '\033[34m-=-')
Carai
Meu Pai do céu
Definição de "Cara foda" atualizada com sucesso
Brabo demais! Só fiz uma correção no seu código:
lista_operadores = ['+', '-', '/', '*', '^']
if expressao[0] in lista_operadores:
print('\033[31mERRO7: A expressão começa com operadores. FALTA NÚMERO OU INCÓGNITA')
erro = 7
Os 2 primeiros itens da lista de operadores são o + e o -, ou seja, negativo e positivo, e isso tornaria -20+(30*3) errado, sendo que um número ser negativo não é um problema.
Por isso fiz a seguinte alteração:
if expressao[0] in lista_operadores[2:]:
dessa forma, o código só vai verificar se a expressão começa com ['/', '*', '^'], o que estaria plenamente incorreto. Mas parabéns cara! O seu código ficou maravilhoso, e se isso já faz um ano, não consigo nem conceber o quão fera você já está nesse tal de Python!
@@diowgo Nesse caso se a pessoa colocar - + -20+(30*3) ainda considera como certo, pra corrigir isso seria com um outro if la no erro 7?
para parte do print, pode se usar:
print('Sua expressão é válida!' if len(pilha) == 0 else 'Sua expressão é inválida! ')
economiza algumas linhas 😁😁
Professor é top!!!
Segue meu código:
exp = []
aberto = fechado = 0
ed = input('Digite a expressão: ')
exp.append(ed)
for x in exp[0]:
if(x in '('):
aberto += 1
if(x in ')'):
fechado += 1
if(aberto == fechado):
print('A expressão é válida!')
else:
print('A expressão é inválida!')
Eu fiz assim :
frase=str(input("Digite uma expressão matemática"))
vetor_aux=[]
for letra in frase:
if(letra == '('): vetor_aux.append(letra)
if(letra == ')'): vetor_aux.append(letra)
print(vetor_aux)
if(len(vetor_aux)%2 == 0):
l=len(vetor_aux)-1
for k in range(0,len(vetor_aux)):
if(l==k): break
if(vetor_aux[k] == vetor_aux[l]):
print("Expressão inválida")
break
if(k%2==0):
if(vetor_aux[k]== '('):
print("Expressão válida")
break
else:
print("Expressão inválida")
break
l-=1
else:
print("Expressão inválida")
Essa foi minha solução:
l = []
e = l.append(input('Digite a expressão: '))
if l[0].count('(') == l[0].count(')'):
print('Expressão válida')
else:
print('Expressão Inválida')
Muito boa sua logica tambem
Samuel Monteiro a minha ficou igual
Samuel Monteiro ta certo assumindo q a pessoa digitou na ordem certinha, se tiver tudo embaralhado seu código ainda vai apontar como correta
Sua solução tem um problema. Por exemplo, se eu digitar uma expressão assim: a+b)*(c+d
Seu programa dirá que está correto.
boao demais, preciso praticar mais
resolvido com 2 linhas
exp = str(input('Digite a expressão: '))
print('A expressão está correta!' if exp.count('(') == exp.count(')') else 'A expressão está errada!')
assim você só ta verificando a quantidade, e não a ordem, então ele vai considerar certo mesmo quando a ordem estiver errada, por ex em ")a+b()c-2("
@@luch_ml valor = str(input('Digite uma expressão: '))
dir = valor.count('(')
esq = valor.count(')')
soma = dir + esq
if valor[-1] == '(' or valor[0] == ')' or dir != esq:
print('Essa Expresão está incorreta!')
else:
print('Essa Expressão está correta!')
matei essa na lógica
@@relaxingsounds5878 Muito bom!
@@relaxingsounds5878 faltou só acrescentar a situação que aparece os parênteses vazios:
if '()' in valor or valor[-1] == '(' or valor[0] == ')' or dir != esq:
Muito boa! Eu fiz um que deu pro gasto não pegava expressões erradas do tipo )a+b(
expressao = str(input("Digite a sua expressão: "))
abrindo = fechando = 0
for parenteses in expressao:
if parenteses == "(":
abrindo += 1
elif parenteses == ")":
fechando += 1
if abrindo == fechando:
print("Sua expressão está válida!")
else:
print("Sua expressão está errada!")
# 83 Desta vez fiz bem diferente, mas vou replicar o do video para praticar
# Primeiro pensei q a expressão deveria ser 100% válida matemáticamente e tive problemas
# para imaginar como fazer mas depois de reler o enunicado foi bem fácil na verdade
espressao = str(input("Digite uma expressão matemática! "))
aberto = 0
fechado = 0
for c in espressao:
if c == '(':
aberto += 1
elif c == ')':
fechado += 1
if aberto == fechado:
print("A expressão é valida! ")
else:
print("A expressão não é valida! ")
se começar com ')(' na expressão, seu programa considerará válido, mas n deveria.
Tente esse aqui
expressao = input('Digite a expressão:')
lista = []
i=0
for c in expressao:
if c == '(' or c == ')':
lista.append(c)
while True:
if lista[0] == ')':
print('EXPRESSÃO INVÁLIDA!')
print(lista)
break;
else:
while len(lista)>=2:
if lista[i] != lista[i+1]:
lista.pop(0)
lista.pop(0)
else:
break
if len(lista)==0:
print('Esssa é uma expressão válida!')
break
Fiz de uma forma que verifica se não houve algum fechamento no lugar errado:
ex = input('Digite uma expressão matemática: ')
if ')(' in ex and ex.index(')') < ex.index('(') or ex.index(')', 1) < ex.index('(', 1):
ver = 'errada'
else:
if ex.count('(') == ex.count(')'):
ver = 'correta'
else:
ver = 'errada'
print(f'
A expressão está {ver}!')
EU JOGUEI ((3*7)+(321)))-3(3333 E DEU "CORRETA"
eu coloquei (2+9)-(8-(7+9)-(3+5)-2) e deu errada
Fiz com count bem diferente:
exp = str(input('Digite a expressão: '))
exp.split()
if exp.count('(') == exp.count(')'):
print('Expressão correta!')
else:
print('Expressão incorreta!')
fantestico, bem mais simples
JEITO QUE EU FIZ SEM USAR LISTA:
direita1 = esquerda1 = 0
expressao = str(input('Digite a expressão: ')).strip()
for i, v in enumerate(expressao):
if v == '(':
direita1 += 1
elif v == ')':
esquerda1 += 1
if esquerda1 > direita1:
print('Expressão Inválida')
break
else:
if i == len(expressao) - 1:
print('Expressão Válida')
EU FIZ SEM USAR NENHUM LAÇO:
expressão = str(input('Digite sua expressão: '))
Todos_os_parenteses_foram_fechados = expressão.count('(') == expressão.count(')')
if Todos_os_parenteses_foram_fechados:
correta_ou_incorreta = 'válida'
else:
correta_ou_incorreta = 'errada'
print(f'Sua expressão está {correta_ou_incorreta}!')
Cai no mesmo erro de não verificar se o primeiro está aberto ou fechando
De primeira eu fiz um programa q só contasse a quantidade d parênteses mas se estivessem na ordem errada ele não identificava... Após a correção ele ficou assim:
cont = 0
expr = input('Digite a expressão para ser avaliada: ')
c = 0
while c < len(expr):
if c == '(':
cont += 1
elif c == ')':
cont -= 1
c += 1
if cont < 0:
break
if cont == 0:
print('A expressão digitada é valida!')
else:
print('A expressão digitado não é válida')
eu fiz desta forma. Usei apenas 8 linhas e uma logica mais simples.
expr = str(input('Digite sua expressão aqui: '))
aberto = expr.count('(')
fechado = expr.count(')')
if aberto == fechado:
print('Sua expressão é valida')
else:
print('Sua expressão esta invalida')
Minha solução:
*Usei contador*
contador = 0
expressão = str(input('Digite a expressão:'))
for p in expressão:
if p in '()':
contador += 1
if contador % 2 == 0:
print('Expressão Válida!')
else:
print('Expressão Inválida')
eu pensei em resolver assim, nessa lógica, se impar então a expressão é invalida, mas não consegui escrever, muito bom.
tem casos que isso da errado meu bom, tipo se eu botar três ((( e um ), vai cair no seu if e vai dar expressão válida.
para n dar erro nesse caso vc teria q fazer assim
expr = str(input("Digite a Expressão: "))
pilha = 0
for simb in expr:
if simb in "(":
pilha += 1
elif simb in ")":
pilha -= 1
if pilha == 0:
print("Sua expressão está valida")
else:
print("Sua expressão está errada")
@@lobiiscoito8363 Nesse caso então não precisa colocar o "break" no laço?
@@victorfadel06 nao pois eu nao usei while
Oi gente, antes eu não tinha conseguido fazer, mas depois do vídeo tive uma ideia que nem precisaríamos da lista, segue como fiz:
c = 0
express = str(input('Digite uma expressão: '))
for n in express:
if n == '(':
c += 1
elif n == ')':
c-= 1
if c % 2 == 0:
print('Parabéns, sua expressão é válida!')
else:
print('Sinto muito, sua expressão não foi aprovada')
Legal, mas observe o seguinte: se vc colocar, por exemplo, dois parênteses abrindo e nenhum fechando, a expressão vai ser considerada correta.
Tirou onda Ficou top esse exemplo.
ex = str(input('Digite uma expressão: '))
p1 = ex.count('(')
p2 = ex.count(')')
if ex[0] == ')':
print('Expressão errada')
else:
print('Expressão Errada') if p1 > p2 or p2 > p1 else print('Expressão Correta')
Essa resolução está errada amigo. Se você colocar "())(" pra testar, ele vai dizer que a expressão está correta., sendo que não está. Mas é simples de resolver.
ex = str(input('Digite uma expressão: '))
p1 = ex.count('(')
p2 = ex.count(')')
if ex[0] == ')' or ex[-1] == '(':
print('Expressão errada')
else:
print('Expressão Errada') if p1 > p2 or p2 > p1 else print('Expressão Correta')
@@XxGuiGax ainda continua errado, se vc colocar "())((())" pra testar, ele vai dizer que tá correto.
pô meu mano guanabaresco, tu que me ensinou a fazer o programa o mais simples possível, o suficiente para dar certo. Fiz desse jeito, sem usar listas (foi a primeira coisa que me veio à mente):
l = str(input('Entre com a expressão: '))
pa = 0
pf = 0
for c in range(len(l)):
if l[c] == '(':
pa += 1
elif l[c] == ')':
pf += 1
if pa == pf:
print('A expressão está correta.')
else:
print('A expressão está incorreta.')
Pensei em fazer usando for, pensei em fazer apenas comparando com ifs em poucas linhas, até mesmo usando contador. A lógica apresentada do professor foi fantástica e vai servir de experiência!
expressao = str(input('\033[36mDigite a expressão: '))
if expressao.count('(') == expressao.count(')'):
print('Essa expressão é válida!')
else:
print('Essa expressão não é válida!')
Melhor que vi até agora :)
Manooooooooooooooooo, eu conseguir esse sem a ajuda kkkk Mas fiz algo bem mais simples utilizando o count e com uma posibilidade de erro no começo e no fim de cada expressão (Vai que o usuario tenha problema na cabeça kkk)
exp = input("Digite a expressão: ").strip()
if exp[-1] != "(" or exp[0] != ")":
if exp.count("(") == exp.count(")"):
print("Sua expressão está válida! ")
else:
print("Sua expressão está errada! ")
else:
print("Sua expressão está errada! ")
Suponha que o usuario comece digitando assim: ) ou talvez termine digitando assim: (
Eu fiz o codigo com essa possibilidade. Caso a expressão for diferente de ")" (Inicio) ou "(" (Final), independente da quantidade, a expressão já vai está errada.
Utilizei o count para determinar a quantidade de cada um, caso a quantidade dos dois estejam iguais, a expressão é válida!
o que acontece se eu digitar " ( 2+3 )))) * ((((5) " ? O final e o começo estão certos, mas o usuário teve um derrame no meio...
Pequeno detalhe, se iniciarmos qualquer expressão com ')', logo estará errada. Porém se ti ver um parentes a mais '(', ele retornará a validação como correta, mesmo estando errada. Então eu inseri um detalhe para reconhecer esse erro no começo:
exp = str(input('Digite a expressão: '))
teste = list(exp)
d = e = 0
for pos, c in enumerate(teste):
if pos==0 and teste[0]==')':
print('Expressão errada')
else:
if teste[pos] == '(':
d += 1
if teste[pos] == ')':
e += 1
if e == d:
print('Expressão CORRETA!')
else:
print('Expressão INCORRETA!')
Eu percebi o erro de ")"
Vim olhar no YT pq vi esse erro tmb
É só tirar o break do pop
expressao = str(input('Digite sua expressão: '))
lista = []
for c in expressao:
if c == '(':
lista.append(c)
elif c == ')':
lista.pop()
if len(lista) == 0:
print('Válido')
else:
print('Inválido')
A solução q eu cheguei foi utilizar um contador que contasse a quantidade de parentes abrindo e fechando, e depois comparar se a quantidade seria a mesma, para a expressão ser válida. Porém, dessa maneira, não é possível verificar se o parente está abrindo ou fechando de forma correta.
Ex: )a+b(
É uma expressão inválida, pois os parênteses estão invertidos, mas por ter a mesma quantidade abrindo e fechando ele diria que é valida.
Dá pra resolver só com fatiamento de string, bem mais simples.
Criei duas váriaveis (A, B) que contam quantas vezes aparecer '(' e ')', respectivamente, e depois uma condição de igualdade entre as variáveis pra saber se a expressão é válida ou não:
exp = str(input('Digite uma expressão matemática: '))
a = ex.count('(')
b = ex.count(')')
print('Sua expressão está CORRETA!' if a == b else 'Sua expressão está ERRADA')
só vim pra dar like pois ainda n to nessa fase
parabéns acho que poucas pessoas fazem/fariam isso
eu também faço isso já somos 2
consegui fazer com duas linhas!!!!!
ex = str(input('Digite a expressão: '))
print('Expressão válida' if ex.count('(') == ex.count(')') else 'Expressão inválida')
Não. Não conseguiu.
Não é só verificar se o número de parênteses abrindo é o mesmo de parênteses fechando.
É também verificar se eles fecham e abrem na hora certa.
" (6 + 6) )5 + 6( "seria considerado certo, pois há dois parênteses abrindo e dois fechando.
Cheque a resolução do vídeo.
Fiz diferente, funcionou...
ex = str(input('Digite uma expressão: '))
pa = []
pf = []
for sim in ex:
if sim == '(':
pa.append(sim)
elif sim == ')':
pf.append(sim)
print(pa)
print(pf)
if len(pa) == len(pf):
print('Sua expressão esta correta.')
else:
print('Sua expressão esta incorreta.')
O problema é se tiver na ordem errada ex: ")2 + 2(" - Seu código vai reponder que a expressão está correta
@@valterdjunior Eu fui para a aula com uma resolução bem parecida com essa. Só que eu usei um count para cada parênteses abrindo e fechando. Quando eu fiquei testando eu achei esse problema do ")2 + 2(" também. Depois que eu fui entender que estava faltando verificar se estava na ordem correta, como o Guanabara fez cortando cada parênteses a medida que ele achasse seu par.
Bugou minha cabeça, mas foi bom que eu aprendi a pensar dessa nova forma.
Eu "esqueci" que tinha que fazer com lista, mas enfim, está ai minha solução:
expressao = str(input('Digite uma expressão: '))
abertos = 0
fechados = 0
for letra in expressao:
if letra == '(':
abertos += 1
if letra == ')':
fechados += 1
if abertos == fechados:
print('Expressão correta!')
else:
print('Expressão está errada!')
1 ano depois eu segui a mesma lógica que você
Gostei muito do raciocínio da resolução...irei refazer para poder sedimentar essa forma de raciocínio.
Fiz diferente! Fiz utilizando a função count e coloquei pra verificar se a quantidade de parentese abrindo "(" é igual a quantidade fechando ")"
expressao = input('Digite a expressão: ')
exp_list = []
for l in expressao:
exp_list.append(l)
if exp_list.count('(') == exp_list.count(')'):
print('Sua expressão é valida!')
else:
print('Sua expressão não é valida!')
Fiz, mas queria solucionar a expressão e não consegui! Inclusive se eu abrir e fechar na ordem errada ainda funciona e por isso não acho que acertei! Acho que a solução do vídeo também vai dar erro caso a expressão errada começe fechando um parentesis, ja que a pilha estará vazia nesse momento! Enfim, esperar mais aulas pra resolver as expressões!
ex083.py
abre = []
fecha = []
exp = str(input('Digite uma expressão que use parenteses abaixo.
>>>'))
for p, c in enumerate(exp):
if '(' in exp[p]:
abre.append(c)
if ')' in exp[p]:
fecha.append(c)
print('Expressão válida!' if len(abre) == len(fecha) else 'Expressão inválida!')
Solução sem criar qq tipo de lista ou vetor, é só analizar os pares dos parênteses digitados, vc tem o da esquerda e os da direitas, eles tem que ser iguais, se não, não fecha a expressão!!
while True:
entrada = str(input('Digite a expressão: '))
para_esquerda = entrada.count('(')
para_direita = entrada.count(')')
if para_esquerda == para_direita:
print(f'Essa expressão {entrada} é válida.')
else:
print(f'Essa expressão {entrada} é inválida.')
Ué? O meu ficou muito menor, só me lembrei que o professor falou que toda str() é uma lista, aí achei que era desse jeito:
num = (str(input('Digite uma expressão: ')))
pd = num.count('(')
pe = num.count(')')
if pd == pe:
print('Expressão valida')
else:
print('Expressão invalida')
Fiz do mesmo jeito
Af sabia que tava esquecendo alguma função de string hahaha, desisti e vocÊ matou, valeu
@@diegosantos5818 vlw
@@oorial se vc fizer assim, o programa também vai considerar expressões como ")(" ou ")))))(((((", já que a quantidade de parenteses é a mesma
@@TavinOriginal haa agora entendi pq o guana fez daquele jeito! Pq eu fiz tipo o do comentário acima! Só contei se era ambos igual e pronto!
Mas agora vou verificar se a primeira é (
E não)
Alguém me tire uma dúvida: se o usuário digitar uma expressão contendo ") )", nessa ordem, quando a iteração passar pelo segundo ")" não esvaziará a lista pilha [")"], que estará contendo o primeiro ")" ? Senão, por quê? Pois a regra é clara: se o valor for ")" e len(pilha) != 0, esvazia a lista com o método pop.
Tive a mesma dúvida, mas fazendo alguns testes acho que entendi o que acontece.
A lista não vai esvaziar pelo seguinte motivo: o programa só vai adicionar um ")" na lista, caso a pilha estiver vazia, certo?
Só que, quando isso acontecer, o programa vai para o _else_ da linha 9, e por isso vai adicionar o ")" na pilha e logo depois dar um *break* no laço. É esse break que vai garantir que o computador não adicione mais um parêntese ")" e caia na situação que você mencionou.
@@victorbonidasilva2343 já ia perguntar o porquê do break
Pelo que vi o ")" serve somente para remover o "(" que o usuário digitou... se você notar se usuário digitar somente ") )" como vc mencionou a lista está zerada, então vai direto para o else, só assim adicionará o ")" na lista e encerrará o programa pois a expressão estará errada, pois na lista foi adicionado o ")". ai o break é para não ficar adicionando mais vezes o ")" na lista ele encerra, e pula para as condições finais.
se tiver '(' e encontrar outro igual ,ele soma ficando 2 '(' , se em seguida encontrar ')', vai diminuir 1, ai fica apenas um '(' que só será = 0 se tiver outra ')' .
Iguais soma e difrerentes diminui. Deu certo pra mim assim!
Caraaaca, essa explicacao foi muito alem do meu raciocinio:
Segue minha contribuicao
e = input('Type a expression: ')
p1 = list(e)
c1 = p1.count('(')
c2 = p1.count(')')
if c1 == c2:
print('The expression is correct.')
else:
print('The expression is incorrect.')
Eu fiz esse em 5 linhas, basicamente é só contar o número de parenteses que abrem e que fecham e verificar se são iguais:
exp = input('Digite a expressão: ')
if exp.count('(') == exp.count(')'):
print('A expressão está correta!')
else:
print('A expressão está errada!')
Caramba realmente funciona ! olhei teu código ai fiquei absmado na simplicidade , o meu ficou bem grande
Não entendi nada 🤡
Vamos ver de novo para aprendermos, desistir n e uma opção 😊
A) Refazer
B) copiar a resposta
C) acertou
D) desiste
Escolha A isso mostra que você é humilde para assumir, corajoso por admitir e esforçado por tentar.
Escolha B mostra que você está tentando de um jeito superficial e não está dedicado e se esforçando a alegria de conseguir será razoável
Escolha C mostra que você é eficiente e treinou se dedicou e se destaca dos demais e tem um alcance acima de alguns, brilhante
Se você desiste D é apenas algo passageiro na sua vida
E a dúvida de que você não consegue fazer as coisas e todos é mais esperto que você ou você não liga ou é diferente das outras pessoas .
Nunca , jamais desista não importa o que os outros dizem o quanto riem
Siga em frente , deixe eles falarem não importa, apenas estude e não desista !!!
Seremos grandes e suficientes para se garantir em Python !!!🫡
Eu fiz desse jeito
h = input("Digite a expressão")
if h.count('(') > h.count(")") or h.count(')') > h.count("("):
print("Expressão invalida")
else:
print("Expressão valida")
expressao = input('Digite uma expressão: ').strip()
lista = []
for c in expressao:
if c == ')' or c == '(':
lista.append(c)
contando = len(lista)
if contando % 2 == 0:
print('Sua expressão está válida!')
else:
print('Sua expressão está errada !') , esse exercício pensei que era difícil, mas em menos de 10 min terminei ele.
Fiz de uma maneira simples:
exp = str(input('Digite a expressão: '))
if exp.count('(') == exp.count(')') and exp.index('(') < exp.index(')'):
print('Expressão válida')
else:
print('Expressão inválida')
Fiz de um jeito diferente. Usei o count para contar a quantidade de '(' e ')' , depois, verifiquei se a quantidade de ambos era a mesma:
expressao = []
conta = input('Digite a expressão: ')
aberto = conta.count('(')
fechado = conta.count(')')
if aberto == fechado:
print('Sua expressão está correta')
else:
print('Sua expressão está errada')
o meu .count() não funcionou nesse, dava sempre zero!
Utilizei o método count! Assim o programa ficou menor e mais simples de entender.
expressão = (input('Digite sua expressão para verificar se está certa ou errada: '))
cont1 = expressão.count('(')
cont2 = expressão.count(')')
print(f'Esta é a sua expressão: {expressão}. ')
if cont1 == cont2:
print('Sua expressão está correta!')
else:
print('Sua experssão está incorreta.')
🤣Não consegui resolver sozinha. Mas depois de ver as explicações, gostei demais. Aprendi a usar melhor os comandos da aula 17.
feliz por ter consegui resolver mais um sem olhar a resposta..... minha solução foi diferente.... ainda acrescentei o erro, segue aí...
expressão = str(input('digite uma expressão'))
abre = (expressão.count('('))
fecha = (expressão.count(')'))
print (f'a expressão digitada foi {expressão}')
if abre == fecha:
print(f'sua expressão é valida')
elif abre > fecha:
print('expressão inválida, tem mais "(" abrindo do que fechando')
else:
print('expressão inválida, tem mais ")" fechando do que abrindo')
Fiz dessa maneira, tecnicamente toda vez que abrir um '(' vai ter que ter outro ')', utilizei o count para contar os elementos e alimentei uma variável , depois só comparei as duas e caso a quantidade de ( ou ) fosse impar , retornaria a mensagem
lista = []
valor = input('Digite uma expressão: ')
parenteses_esquerda = valor.count('(')
parenteses_direita = valor.count(')')
if parenteses_direita == parenteses_esquerda:
print('A sua expressão é valida!')
else:
print('A sua expressão é invalida!')
Pra quem ta aprendendo nesse ano Python resolvi esse exercício assim:
abre_parênteses = [ ]
fecha_parênteses = [ ]
expressão = input('Digite uma expressão: ')
abre_parênteses.append(expressão.count( '(' ) )
fecha_parênteses.append(expressão.count( ')' ) )
if abre_parênteses == fecha_parênteses:
print('Sua expressão está correta!')
else:
print('Sua expressão está errada!')
Fiz uma solução que funciona, mas detectei um bug durante essa correcção, felizmente consegui compreender o motivo do bug e ajustar o código, fiquem atentos, não é só somar o valores de '(' e ')' e compará los que o resultado será correto, teste com a seguinte expressão '(a*b)-)c(=12' o retorno deve ser o de um expressão invalida.
Na minha resolução fiz o programa analisar cada parte da expressão . Se o parenteses abre, ele adiciona em uma lista, se ele fecha, ele é adicionado em outra lista, no final, as duas tem que ter o mesmo comprimento.
parentesesr_abre = [ ]
parenteses_fecha= [ ]
expressao = input( 'Digite a expressão: ')
for c in expressao:
if c == ' ( ':
parenteses_abre.append( ' ( ' )
elif c == ' ) ':
parenteses_fecha.append( ' ) ' )
if len(parenteses_abre) == len(parenteses_fecha):
print('Expressão válida! ')
else:
print('Expressão inválida! ')
Não desistam, dificuldades existem para que você possa lidar com um problema maior no futuro✌
Fiz dessa forma :
expr = input('Digite uma expressão')
abert = []
fech = []
for c in expr:
if c == '(':
abert.append(c)
elif c == ')':
fech.append(c)
if len(abert) == len(fech):
print('expressão correta')
else:
print('Expressão errada')
não terminei de fazer mas deu pra entender bem a logica desse exercício.
eu fiz e deu certo eu criei duas listaa toda vez que aparecesse um eu adicionava numa lista e no final comparava duas listas
Primeiramente: PARABÉNS, Guanabara e equipe!!!
Segundamente: Segue solução diferente, com comentários:
import sys # Importação do sys para interromper a execução do programa em caso de "Expressão incorreta".
expressao = ""
posicao_abertura = [] # Lista com a posição dos parêntesis de abertura da expressão digitada
posicao_fechamento = [] # Lista com a posição dos parêntesis de fechamento da expressão digitada
expressao = (input('Digite uma expressão qualquer que use parêntesis: '))
for pos, caractere in enumerate(expressao):
if caractere == '(':
posicao_abertura.append(pos) # Acrescenta a posição do parêntesis de abertura à lista posicao_abertura
elif caractere == ')':
posicao_fechamento.append(pos) # Acrescenta a posição do parêntesis de fechamento à lista posicao_fechamento
else:
continue
print(f'Expressão digitada: {"".join(expressao)}') # Imprime a expressão digitada
if len(posicao_abertura) != len(posicao_fechamento): # Verifica se a quantidade de parêntesis de abertura é diferente da quantidade de fechamento
print('Expressão incorreta (quantidade de parêntesis de abertura diferente dos de fechamento).')
sys.exit()
else: # Se a quantidade de parêntesis de abertura e de fechamento forem iguais, o código passa a verificar se estão em ordem correta
posi = 0
while posi < len(posicao_abertura):
decrescente = -1
if posicao_abertura[posi] < posicao_fechamento[decrescente]:
# A linha acima compara se a posição do parêntesis de abertura (em ordem crescente da lista posicao_abertura)
# é menor do que a posição do parêntesis de fechamento (em ordem decrescente da lista posicao_fechamento)
decrescente -= 1 # Atualiza a variável "decrescente"
posi += 1 # Atualiza a variável "posi"
continue
else:
print('Expressão incorreta.')
sys.exit()
# Caso o programa não execute nenhum dos dois "sys.exit()" acima, a expressão estará correta:
print('Expressão correta!!!')
# Caso queira ver o conteúdo das listas posicao_abertura e posicao_fechamento, segue código abaixo:
if len(posicao_abertura) >= 1:
posicao_abertura.sort()
print(f'Lista posicao_abertura: {", ".join(str(n) for n in posicao_abertura)}')
if len(posicao_fechamento) >= 1:
posicao_fechamento.sort()
print(f'Lista posicao_fechamento: {", ".join(str(n) for n in posicao_fechamento)}')
A versão mais simples de todas (usando lista, pq também é possível fazer sem usar lista) que encontrei é assim...
lista = []
expressao = str(input('Digite a expressão: '))
for i in range(0, len(expressao)):
lista.append(expressao[i])
print('Sua expressão está correta!') if lista.count('(') == lista.count(')')
else print('Sua expressão está errada!')
Usei o método count para resolver
exp = str(input('Digite uma expressão: '))
lista = list(exp)
if lista.count('(') == lista.count(')'):
print('A expressão é válida')
else:
print('A expressão não é válida')
Tinha feito assim:
e = input(' Digite a expressão: ')
if e.count('(') == e.count(')'):
print(' Sua expressão está válida!')
else:
print(' Sua expressão está errada!')
Estava feliz em ter conseguido com poucas linhas, algo como "())( " daria como expressão válida..
😅
par_esq = par_dir = cont = 0
expressao = str((input('digite uma expressao: ')))
while cont < len(expressao):
if '(' in expressao[cont]:
par_esq += 1
else:
if ')' in expressao[cont]:
par_dir += 1
cont += 1
if par_dir == par_esq:
print('a expressao eh valida!!')
else:
print('a expressao eh invalida!!!')
se usar a lógica todo parentesis deve ser fechado em algum momento, dessa forma a expressao só é válida se o número de "( "e ")" for par, se for ímpar é porque algum parentesis nao foi fechado, usei essa logica no meu codigo:
expressao = input('digite a expressão: ')
contagem = expressao.count("(") + expressao.count(")")
if contagem % 2 == 0:
print('a expressao é válida')
elif contagem == 0:
print('isso não é uma expressao')
else:
print('a expressao não é válida')
expressao = []
exp = input("Digite uma expressão matemática com parênteses: ")
expressao.append(exp)
for expr in expressao:
print(f"A expressão {expr}",end=' ')
if expr.count('(') == expr.count(')') and exp[0]!=')':
print("é uma operação válida")
else:
print("é uma operação inválida.")
Pensei desse jeito. Não sei se atende as necessidades da lista, mas cumpre a função
Eu vi várias resoluções que apresentam uma possível resolução de uma forma mais simples, porém uma grande parte apresentava uma falha - não analisava as posições do mesmo.
Consegui fazer de uma forma que não é tão "clean" quanto a do professo, mas resolvendo o problema para analisar as posições.
expressão = list()
expressão.append(input('Digite um expressão: '))
sige = sigd = posd = pose = ige = igd = 0
for exp in expressão:
for pos, carac in enumerate(exp):
if carac in '(':
sigd += 1
posd = pos
if carac in ')':
sige += 1
pose = pos
if sige == sigd:
if posd < pose:
ige += 1
igd += 1
if ige == igd and ige != 0 and igd != 0:
print('Sua expressão está correta!')
else:
print('Sua expressão está incorreta.')
resolução:
e = str(input('digite uma expressão(com parenteses):'))
n = e.count('(')
n1 = e.count(')')
if n == n1:
print('expressão valida')
else:
print('expressão invalida')