ArteEN

você deve tratar a saida do input, caso não seja o que você espera, devem pedir novamente a entrada você faz isso com while, if/else

Certo, acho que compreendi Na linha 40: Pegou um objeto do array v para k Na linha 42: Chega a operação binaria do while v[j].codigo > k você esta comparando um int > tp_tab_2 você deve comparar int > int

Na linha 40: Acusa tipos incompatíveis k = v; k é do tipo tp_tab_1 e v é do tipo tp_tab2 Linha 42: Acusa tipo incompatível para o argumento 2 Esta esperando um const char, mas esta recebendo um tp_tab2 Isso é para as acusações de erro do isort strcmp é uma função para strigns, v[j].codigo é um int

coloque o codigo como esta agora

#define PI 3.14 float raio, altura; double volume; scanf("%f", &raio); scanf("%f", &altura); volume = PI * raio * 2 * altura printf("%f", volume); Demais estruturas e validações são por sua conta

Seu código esta bem bagunçado Este calculo pode ser resolvido de forma bem simples No seu código: Linha 5: #define pi 3.141592 Esta comentado, não terá efeito no programa, eu tiraria esta linha do comentário para ser usada Linha 9: Se você usar a constante simbólica não irá precisar declarar pi Linha 11: Neste momento no programa você esta usando lixo de memoria para raio e altura, é um calculo desnecessário neste momento. Linha 13: não é necessário declarar inteiros para o calculo Linha 21 a 32: São linhas sem sentido para o programa (usar um inteiro para validar o volume) Demais linhas: A apresentação do resultado tambem esta incompleta Minhas sugestões: Crie a constante simbólica PI Declare float raio, altura Declare double volume Peça a entrada do raio e altura Faça o calcule do volume Exiba o resultado

Fiz um código aqui, comecei a estudar c a pouco tempo #include <stdio.h> int main() { int numeroqualquer, i = 0; float s = 0; puts("Digite um valor inteiro positivo:"); scanf("%d", &numeroqualquer); while(numeroqualquer < 1) { puts("\nErro na entrada do valor\n\nEntre um valor inteiro positivo"); fflush(stdin); scanf("%d", &numeroqualquer); } while(i++ < numeroqualquer) s += 1.0 / i; printf ("\n----------------------------------------------------"); printf("\n------------------- RESULTADO ----------------------\n"); printf("\nResultado Final: %.6f", s); printf ("\n\n----------------------------------------------------"); return 0; }

Ola. A parte do if na linha 6 e 7 é para arredondar o numero de latas. litros_necessarios = 24.3 total_gal_18 = litros_necessarios // 18 # 1 galão de 18 litros resto = litros_necessarios % 18 # resta 6.3 litros para serem convertidos em latas total_latas_3 = resto / 3 # retorna 2.1 latas # .1 na verdade são .3 litros if total_latas_3 > int(total_latas_3): # conversão para int desconsidera o quebrado, então 2.1 > 2 total_latas_3 = int(total_latas_3) + 1 #acrescenta mais uma lata para cobrir os .3 litros que falta para a pintura Ainda sim, isso ainda tem que ser refinado. Eu fiz o codigo ao meu estilo, claro ainda da para melhorar em algumas declarações mas não se assuste, ainda estou aprendendo . ## sep = "-" * 30 # separador para o print ##Recipientes e seus valores latas_l = 3 #latas de tinta de tres litros e seu valor latas_v = 25 galao_l = 18 #galões de tinta de 18 litros e seu valor galao_v = 80 tinta_r = 6 #rendimento da tinta, 1 litro para 6 metros ##Definindo area metros = float(input("Entre com a area: ")) #pega a area total em float area = metros * 1.1 #acrescimo de 10 % area_i = int(area) #convertendo para int desconsidera o quebrado area_r = area - area_i #pegamos o resto da area area_total = area_i if area_r == 0 else area_i + 1 #ternario para arredondar o valor print("\n{}\nArea inicial: {:.2f} metros\nArea acrescida em 10%: {:.2f} metros\nArea final: {:.2f} metros\n\n{}".format(sep, metros, area, area_total, sep)) ##Definindo litros a usar litros_i = area_total // tinta_r #litros nessessarios litros_f = area_total % tinta_r #sobra litros_final = litros_i if litros_f == 0 else litros_i + 1 #ternario para arrendodar o valor print("Litros nessessarios: {}lt\n\n{}".format(litros_final, sep)) ##Calcular galões e latas galao_1 = litros_final // galao_l #galões de 18 litros galao_2 = litros_final % galao_l #sobra galao_3 = galao_1 + 1 if galao_2 > 0 else galao_1 #arredonda o numero de galões latas_1 = litros_final // latas_l #latas de 3 litros latas_2 = litros_final % latas_l #sobra latas_3 = latas_1 + 1 if latas_2 > 0 else latas_1 #arredonda o numero de latas ##Calcular valores #apenas latas latas_lt = latas_3 * latas_l #total de litros latas_ls = latas_lt - litros_final #litros a mais latas_vt = latas_3 * latas_v #valor total print("Valor calculado sobre latas de {}lt\nNº de latas: {}\nTotal em litros: {}lt\nSobra: {}lt\nValor: {:.2f}R$\n\n{}".format(latas_l, latas_3, latas_lt, latas_ls, latas_vt, sep)) #apenas galões galao_lt = galao_3 * galao_l #total de litros galao_ls = galao_lt - litros_final #litros a mais galao_vt = galao_3 * galao_v # valor total print("Valor calculado sobre galões de {}lt\nNº de galões: {}\nTotal em litros: {}lt\nSobra: {}lt\nValor: {:.2f}R$\n\n{}".format(galao_l, galao_3, galao_lt, galao_ls, galao_vt, sep)) #mesclando galões e latas latas_4 = galao_2 / 3 #calcular latas a partir do resto de galões latas_5 = int(latas_4) + 1 if latas_4 > int(latas_4) else int(latas_4) #arredondar latas valor_3 = galao_1 * galao_v #valor de galões valor_4 = latas_5 * latas_v #valor de latas valor_5 = valor_3 + valor_4 #soma final litros_t = galao_1 * galao_l + latas_5 * latas_l #soma de litros entre galão e latas sobra = litros_t - litros_final print("Valor calculado sobre galões de {}lt e latas de {}lt\nNº de galões: {}\nNº de latas: {}\nTotal em litros: {}lt\nSobra: {}lt\nValor: {:.2f}R$".format(galao_l, latas_l, galao_1, latas_5, litros_t, sobra, valor_5))

Eu fiz um pequena confusão você diz latas de 18 litros, eu digo galão de 18 litros , isso me confundiu nas variaveis Então vamos a logica para o calculo da etapa 3. Recipiente de 18 litros é mais barato. então começamos o calculo por ele e depois a parte mais demorada é calcular o restante em latas total_gal_18 = litros_necessários // 18 resto = litros_necessários % 18 total_latas_3 = resto / 3 if total_latas_3 > int(total_latas_3): total_latas_3 = int(total_latas_3) + 1 Então você tem o total de em recipientes de 18 litros: total_gal_18 O necessário em recipientes de 3 litros: total_latas_3 Basta calcular o valor.

Ola vamos tentar no passo a passo dos resultados: print("2)") latas = total//18 # Recebe 0 caso o total seja 12 ? Sim recebe zero # vc pode fazer o teste no console interativo if total % 18 > 0: # no console 12 % 18 é 12 então 12 > 0? Sim então latas vai para 1 latas += 1 #total vai continuar 12 pois ñ tem comandos para alterar Na parte 3 tem alguns pontos a corrigir print("\n3) Misturar latas e galões, de forma que o preço seja o menor.") latas = total//18 #Aqui vc tem o numero de galões ñ de latas galoes = 0 #Ñ nessessario, na teoria a linha passada ja deu o numero de galões litros_restantes = total % 18 #isso vc retira um galão do total de litros, oq acontece se vc precisar de 100 litros? Comprar 28 latas? print() print("#################### latas atual",latas) # galões, ñ latas print("#################### litros restantes atual",litros_restantes) print() if litros_restantes <= 3: #Ou seja, o numero de galões necessários seja menor do que três. galoes = litros_restantes // 3 if litros_restantes % 3 > 0: galoes += 1 else: latas += 1 print("#################### galoes atual",galoes) print("#################### litros restantes atual",litros_restantes) print ("Serão necessárias:", latas, "lata(s)") print ("Serão necessários:", galoes, "galão(s)") print ("Obteremos:", latas*18 + galoes*3, "litros") print ("Total: R$", galoes*25 + latas*80) O if da parte 3 você deve arrumar para trabalhar em cima das latas. Tem comentários no código a cima apontando algumas correções

Pode ser que a função tenha mais sentido fora da classe do que dentro, um exemplo seria uma função para retornar um relatório de estados dos objetos. Duas ou mais classes em um arquivo .py pode significar que o programa seja simples o suficiente para usar apenas um arquivo Ou as duas classes tem alguma relação entre si e deixar as duas juntas pode facilitar nas edições futuras

TypeError: not callable Ocorre quando você tenta usar um objeto como função, sendo que este objeto não é uma função a = 1 a() TypeError: 'int' object is not callable def a(arg): print(arg) a('uma função é um objeto executável') 'uma função é um objeto executável' 'module' não é callable, significa que o modulo não é executável, como é um modulo você deve estar executando ele de forma errada ou incompleta, talvez na intenção de chamar um método Então você tem que procurar no seu código a parte de criação do Controle_Personagens(), e ver se ele foi criado devidamente

Bom, se você notar, quando mover a parte de baixo da matriz estará juntando o fim da primeira fila, com o inicio da segunda, isso se repete pelo numero de filas totais da matriz menos 1, então você joga essa ideia em um for

Bom camarada, o problema que vejo é a na forma que o toupper() esta sendo feito. Veja a logica que acontece com a variável char sexo desdo inicio do programa e me diga o valor que ela ira chegar no if da gratificação por tempo de trabalho Não seria melhor trocar a estrutura if/else if por um Switch?

Ola camarada, não sou de muita ajuda, posso apenas fazer suposições Pequei a documentação do pygame.mouse.get_pressed() Nela diz que este método retorna uma lista de booleanos, sendo True para o acionamento Não diz como pegar o click em algum sprite, já tentou fazer um print(pygame.mouse.get_pressed()) e print(pygame.mouse.get_pressed(icone_01)) para ver o retorno? Se no segundo caso o retorno ainda for uma lista de booleanos, a saída que vejo é pegar a localização do do mouse e ver se esta dentro da matriz do sprite, e então fazer o if/elif junto ao click do mouse

Certo terminei de baixa, passei um tempo vasculhando atrás do problema. O erro esta na importação. from scipy.integrate import quad from sympy.mpmath import * você importou o quad do scipy, tudo certo E aqui esta o problema, você importou tudo do sympy, o que acontece é que dentro do sympy tem um metodo quad, então este segundo passa a ter a referencia para quad Então da um erro pois os argumentos não batem, pois claro é um função totalmente diferente Tem 3 soluções from scipy import integrate # usar integrate.quad from sympy.mpmath import * from scipy.integrate import quad as outroQuad # dar um novo nome from sympy.mpmath import * Ou a solução mais engraçada from sympy.mpmath import * from scipy.integrate import quad Inverter a ordem de import faz com que o quad vindo do scipy tenha a referencia

Segundo as pesquisas que fiz, este problema é justamente para ilustrar as dificuldade de programação com multiplos threads Bom, tirando este objetivo, penso que seria fácil ilustrar este problema usando objetos

Ola amigo, eu acho que você não executou de forma correta a logica que te passei. Então para facilitar, vai ai o codigo public class NumeroMaior { public static void main(String[] args) { int m = 0, m2 = 0, num; Scanner entrada = new Scanner(System.in); System.out.println("Entre dez numeros inteiros "); for (int count = 0; count < 10; count++){ num = entrada.nextInt(); if (num > m){ m2 = m; m = num; } else if (num > m2){ m2 = num; } System.out.println("Maior >>> " + m + "\n" + "Segundo maior >>> " + m2); } } } Enxuguei os prints deixando apenas o necessário para visualizar o código funcionando. Apos cada entrada um print mostra o maior e o segundo maior já processados na ordem correta

Sim para todas as perguntas Eu tambem estudo por conta e levei um pouco de tempo para ver o padrão que existe na programação Passei muito tempo pensando que cada linguagem era algo unico, mas não, são extremamente similares. Acho que a maior diferença que vi foi entre linguagens de baixo e alto nivel, digo a forma liberal da linguagem alta e a formalidade da linguagem baixa. Só muda a forma de concepção do codigo, mas no centro de tudo estão lá, os if, elses da vida. E claro, pacotes , bibliotecas, módulos, mas isso tem mais a ver com o objetivo da linguagem

Minha net é bastante lenta, vai demorar a terminar o download. Avise caso você consiga resolver neste tempo

quad(func, a, b, args=()) func ---- sua função a e b ---- floats para a integração args = () ---- tupla com argumentos opcionais para a função result = quad(i_2, 0, pi, args = (k, )) Espero que funcione assim, o ruim é que eu não consigo baixa o scipy

Recomendo ver passagem de argumento, vai ter ajudar. Aqui a função completa na documentação. quad(func, a, b, args=(), full_output=0, epsabs=1.49e-08, epsrel=1.49e-08, limit=50, points=None, weight=None, wvar=None, wopts=None, maxp1=50, limlst=50) Aqui ela limpa, como o que aparenta ser a sua intenção de uso. quad(func, a, b, args=()) Aqui como você deve usar a função quad(Sua_função, argumento_a, argumento_b, args=(argumentos_opcionais_1, ))

O unico problema que vejo é a função quad que não esta como a documentação quad(func, a, b, args=()) ----- A sim e mais um provavel problema. def i_2(x, k) esta sem retorno

Esse erro diz que você esta passando um inteiro quando devia passar um objecto que tenha __len__ Tupla e listas são objetos que tem o atributo __len__ Só por tira duvida você pode mostrar como esta o codigo neste momento?

Ola Isadora Na documentação https://docs.scipy.org/doc/scipy-0.15.1/reference/generated/scipy.integrate.quad.html#scipy.integrate.quad Mostra que args é uma tupla opcional. Na interação você passa um inteiro e não uma tupla Fica mais ou menos assim quad(i_2, 0, pi, args = (1, 2)) # ou quad(i_2, 0, pi, args = (i, )) # isso se vc quiser manter a interação