Ofereço ajuda em Java, C/C++, Python, C#, LISP, AutoLisp, AutoCAD
+55 (062) 98553-6711
Ofereço ajuda em PHP, Python, C#, JavaScript, Laravel, Google Ads e SEO
+55 (062) 98243-1195

Você está aqui: Python ::: Desafios e Lista de Exercícios Resolvidos ::: Laços de Repetição

Como calcular a tabuada de multiplicação para os números de 1 a 9 em Python - Exercícios Resolvidos de Python

Quantidade de visualizações: 372 vezes
Pergunta/Tarefa:

Escreva um programa Python que usa o laço for para calcular e exibir a tabuada de multiplicação dos números 1 a 9.

Sua saída deve ser parecida com:

        Tabuada de Multiplicação
----------------------------------------------
       1   2   3   4   5   6   7   8   9
----------------------------------------------
1  |   1   2   3   4   5   6   7   8   9
2  |   2   4   6   8  10  12  14  16  18
3  |   3   6   9  12  15  18  21  24  27
4  |   4   8  12  16  20  24  28  32  36
5  |   5  10  15  20  25  30  35  40  45
6  |   6  12  18  24  30  36  42  48  54
7  |   7  14  21  28  35  42  49  56  63
8  |   8  16  24  32  40  48  56  64  72
9  |   9  18  27  36  45  54  63  72  81
Resposta/Solução:

Veja a resolução comentada deste exercício usando Python:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

# método principal
def main():
  # mostra o título da tabela
  print("        Tabuada de Multiplicação")
  print("\n----------------------------------------------")
     
  # exibe os números na parte superior
  print("       ", end='')
  for i in range(1, 10):
    print("{0}   ".format(i), end='')  
     
  print("\n----------------------------------------------")
  
  # mostra o corpo da tabuada
  for i in range(1, 10):
    print("{0}  |".format(i), end='')
    
    for j in range(1, 10):
      print("%4d" % (i * j), end='')
    
    print()

if __name__== "__main__":
  main()


Link para compartilhar na Internet ou com seus amigos:

Python ::: Python para Engenharia ::: Geometria Analítica e Álgebra Linear

Como converter Coordenadas Polares para Coordenadas Cartesianas usando Python - Python para Engenharia

Quantidade de visualizações: 5614 vezes
Nesta nossa série de Python para Geometria Analítica e Álgebra Linear, mostrarei um código 100% funcional para fazer a conversão entre coordenadas polares e coordenadas cartesianas. Esta operação é muito frequente em computação gráfica e é parte integrante das disciplinas dos cursos de Engenharia (com maior ênfase na Engenharia Civil).

Na matemática, principalmente em Geometria e Trigonometria, o Sistema de Coordenadas Polares é um sistema de coordenadas em duas dimensões no qual cada ponto no plano é determinado por sua distância a partir de um ponto de referência conhecido como raio (r) e um ângulo a partir de uma direção de referência. Este ângulo é normalmente chamado de theta (__$\theta__$). Assim, um ponto em Coordenadas Polares é conhecido por sua posição (r, __$\theta__$).

Já o sistema de Coordenadas no Plano Cartesiano, ou Espaço Cartesiano, é um sistema que define cada ponto em um plano associando-o, unicamente, a um conjuntos de pontos numéricos.

Dessa forma, no plano cartesiano, um ponto é representado pelas coordenadas (x, y), com o x indicando o eixo horizontal (eixo das abscissas) e o y indicando o eixo vertical (eixo das ordenadas). Quando saímos do plano (espaço 2D ou R2) para o espaço (espaço 3D ou R3), temos a inclusão do eixo z (que indica profundidade).

Antes de prosseguirmos, veja uma imagem demonstrando os dois sistemas de coordenadas:



A fórmula para conversão de Coordenadas Polares para Coordenadas Cartesianas é:

x = raio × coseno(__$\theta__$)
y = raio × seno(__$\theta__$)

E aqui está o código Python completo que recebe as coordenadas polares (r, __$\theta__$) e retorna as coordenadas cartesianas (x, y):

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

# importamos a biblioteca NumPy
import math as math
  
def main():
  # vamos ler o raio e o ângulo
  raio = float(input("Informe o raio: "))
  theta = float(input("Informe o theta: "))
  graus = input("Theta em graus (1) ou radianos (2): ")

  # o theta está em graus?
  if graus == "1":
    theta = theta * (math.pi / 180.0)      
  
  # fazemos a conversão para coordenadas cartesianas 
  x = raio * math.cos(theta)
  y = raio * math.sin(theta)

  # exibimos o resultado
  print('As Coordenadas Cartesianas são: (x = %0.2f, y = %0.2f)' %(x, y)) 

if __name__== "__main__":
  main()

Ao executar este código nós teremos o seguinte resultado:

Informe o raio: 1
Informe o theta: 1.57
Theta em graus (1) ou radianos (2): 2
As Coordenadas Cartesianas são: (x = 0.00, y = 1.00)


Python ::: Itertools ::: Iteradores de Combinação e Permutação

Como gerar permutações de uma string em Python usando o objeto permutations do módulo Itertools

Quantidade de visualizações: 831 vezes
Nesta dica mostrarei como podemos usar o objeto permutations do módulo Itertools para gerar as permutações simples de uma string.

Na permutação simples, quando os elementos não se repetem, a quantidade de conjuntos gerados a partir do conjunto analisado equivale a n!, onde n é a quantidade de elementos no conjunto a partir do qual a permutação ocorrerá.

Dessa forma, para a palavra LOTE, a quantidade de permutações possíveis (sem repetição) é 4! = 24.

Veja o código Python completo que gera as permutações simples para a palavra LOTE:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

# vamos importar o objeto permutations do Itertools
from itertools import permutations

def main():
  # palavra contendo os caracteres que queremos
  # gerar a permutação. Veja que não vamos usar
  # caracteres repetidos
  palavra = "LOTE"

  # agora obtemos uma lista com as permutações possíveis
  permutacoes = [''.join(p) for p in permutations(palavra)]

  # e mostramos o resultado
  print("As permutações para a palavra {0} são:\n".format(palavra))
  print(permutacoes)

if __name__== "__main__":
  main()

Ao executar este código Python nós teremos o seguinte resultado:

As permutações para a palavra LOTE são:

['LOTE', 'LOET', 'LTOE', 'LTEO', 'LEOT', 'LETO', 'OLTE', 'OLET', 'OTLE', 'OTEL', 'OELT', 'OETL', 'TLOE', 'TLEO', 'TOLE', 'TOEL', 'TELO', 'TEOL', 'ELOT', 'ELTO', 'EOLT', 'EOTL', 'ETLO', 'ETOL']


Python ::: Dicas & Truques ::: Formatação de datas, strings e números

Python para iniciantes - Como inserir uma determinada quantidade de espaços à direita de uma string

Quantidade de visualizações: 8479 vezes
Este trecho de código mostra como inserir uma determinada quantidade de espaços à direita de uma string. Esta técnica é muito útil para formatar a saída em tela ou em arquivos.

Veja o código completo para a dica:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

def main():
  palavra1 = "Estudando"
  palavra2 = "Python"
  palavra3 = "C++"
  palavra4 = "Delphi"
 
  print("%-12s %s" % (palavra1, palavra2))
  print("%-12s %s" % (palavra3, palavra4))
 
if __name__== "__main__":
  main()

Ao executarmos este código Python nós teremos o seguinte resultado:

Estudando    Python
C++          Delphi



Python ::: Dicas & Truques ::: Geometria, Trigonometria e Figuras Geométricas

Como calcular a equação reduzida da reta em Python dados dois pontos pertencentes à reta

Quantidade de visualizações: 3124 vezes
Nesta dica de Python veremos como calcular a equação reduzida da reta quando temos dois pontos pertencentes à esta reta. Não, nessa dica não vamos calcular a equação geral da reta, apenas a equação reduzida. Em outras dicas do site você encontra como como isso pode ser feito.

Para relembrar: a equação reduzida da reta é y = mx + n, em que x e y são, respectivamente, a variável independente e a variável dependente; m é o coeficiente angular, e n é o coeficiente linear. Além disso, m e n são números reais. Com a equação reduzida da reta, é possível calcular quais são os pontos que pertencem a essa reta e quais não pertencem.

Vamos começar então analisando a seguinte figura, na qual temos dois pontos que pertencem à uma reta:



Note que a reta da figura passa pelos pontos A(5, 5) e B(9, 2). Então, uma vez que já temos os dois pontos, já podemos calcular a equação reduzida da reta. Veja o código Python completo para esta tarefa:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

# método principal
def main():
  # vamos ler as coordenadas do primeiro ponto
  x1 = float(input("Coordenada x do primeiro ponto: "))
  y1 = float(input("Coordenada y do primeiro ponto: "))
  
  # vamos ler as coordenadas do segundo ponto
  x2 = float(input("Coordenada x do segundo ponto: "))
  y2 = float(input("Coordenada y do segundo ponto: "))
 
  sinal = "+"
  # vamos calcular o coeficiente angular da reta
  m = (y2 - y1) / (x2 - x1)
  # vamos calcular o coeficiente linear
  n = y1 - (m * x1)
 
  # coeficiente linear menor que zero? O sinal será negativo
  if (n < 0):
    sinal = "-"
    n = n * -1
  
  # mostra a equação reduzida da reta
  print("Equação reduzida: y = %.2fx %s %.2f" % (m, sinal, n))

if __name__== "__main__":
  main()

Ao executar este código Python nós teremos o seguinte resultado:

Coordenada x do primeiro ponto: 5
Coordenada y do primeiro ponto: 5
Coordenada x do segundo ponto: 9
Coordenada y do segundo ponto: 2
Equação reduzida: y = -0,75x + 8,75

Para testarmos se nossa equação reduzida da reta está realmente correta, considere o valor 3 para o eixo x da imagem acima. Ao efetuarmos o cálculo:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

>> y = (-0.75 * 3) + 8.75
y = 6.5000

temos o valor 6.5 para o eixo y, o que faz com que o novo ponto caia exatamente em cima da reta considerada na imagem.


Python ::: Python para Engenharia ::: Engenharia Civil - Cálculo Estrutural

Como calcular a Força Normal Adimensional ou Força Normal Reduzida de um pilar em Python - Python para Estruturas de Concreto Armado

Quantidade de visualizações: 328 vezes


A Força Normal Adimensional de um pilar, também chamada de Força Normal Reduzida, é representada pela letra grega &#957; (ni) e nos dá uma idéia da magnitude da força normal que está sendo aplicada na seção transversal de um pilar.

A fórmula para o cálculo da Força Normal Adimensional pode ser representada da seguinte forma:

\[\nu = \frac{N_\text{sd}}{A_\text{c} \cdot \frac{f_\text{ck}}{\gamma _\text{c}}} \]

Onde:

&#957; é a Força Normal Adimensional sem unidade;

Nd é a força normal de projeto, em kN.

fck é a resistência característica do concreto em kN/cm2. Para converter de Mpa para kN/cm2 nós só precisamos dividir por 10.

&#947;c é o fator de ponderação do concreto e, em geral, possui o valor 1,4. Ao dividirmos o fck pelo &#947;c nós chegamos ao fcd, que é resistência de cálculo do concreto.

Note que o valor encontrado para a força normal adimensional &#957; (ni) é o valor que, junto com o &#956; (mi), forma a dupla de fatores para o ábaco de VENTURINI que nos retornará o valor de &#969; (ômega) que nos ajudará a calcular a área de aço (As) do pilar.

Há duas considerações importantes em relação à Força Normal Adimensional &#957; de um pilar:

a) Se &#957; < 0,30 -> pode ser adequado reduzir a seção transversal do pilar.

b) Se &#957; > 1,30 -> pode ser conveniente aumentar a seção transversal do pilar.

Agora vamos ver o código Python? Note que pediremos para o usuário informar as dimensões do pilar nas direções x e y em centímetros, a carga total no pilar em kN e o fck do concreto em Mpa e retornaremos o valor da força normal adimensional:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

# método principal
def main():
  # vamos pedir as dimensões do pilar
  hx = float(input("Informe a dimensão do pilar na direção x (em cm): "))
  hy = float(input("Informe a dimensão do pilar na direção y (em cm): "))

  # vamos pedir a carga total no pilar em kN
  Nk = float(input("Informe a carga total no pilar (em kN): "))

  # agora vamos obter o FCK do concreto em MPa
  fck = float(input("Informe o FCK do concreto (em MPa): "))
  # vamos converter MPa para kN/cm2
  fck = fck / 10

  # vamos obter o menor lado do pilar (menor dimensão da seção transversal)
  if (hx < hy):
    b = hx
  else:
    b = hy

  # agora vamos calcular a área do pilar em centímetros quadrados
  area = hx * hy
 
  # a área está de acordo com a norma NBR 6118 (ABNT, 2014)
  if (area < 360):
    print("A área do pilar não pode ser inferior a 360cm2")
    return

  # vamos calcular a força normal de projeto Nd
  yn = 1.95 - (0.05 * b) # de acordo com a norma NBR 6118 (ABNT, 2014) Tabela 13.1
  yf = 1.4 # regra geral para concreto armado
  Nd = yn * yf * Nk

  # vamos fixar o fator de ponderação do concreto em 1.4
  yc = 1.4

  # e agora calculamos a força normal adimensional do pilar
  fna = Nd / (area * (fck / yc))

  # e mostramos o resultado
  print("\nA Força Normal Adimensional do pilar é: {0}".format(round(fna, 2)))

if __name__== "__main__":
  main()

Ao executar este código Python nós teremos o seguinte resultado:

Informe a dimensão do pilar na direção x (em cm): 40
Informe a dimensão do pilar na direção y (em cm): 19
Informe a carga total no pilar (em kN): 841.35
Informe o FCK do concreto (em MPa): 30

A Força Normal Adimensional do pilar é: 0.72


Python ::: Dicas & Truques ::: Trigonometria - Funções Trigonométricas

Como calcular o comprimento da hipotenusa em Python dadas as medidas do cateto oposto e do cateto adjascente

Quantidade de visualizações: 1587 vezes
Nesta dica mostrarei como é possível usar a linguagem Python para retornar o comprimento da hipotenusa dadas as medidas do cateto oposto e do cateto adjascente. Vamos começar analisando a imagem a seguir:



Veja que, nessa imagem, eu já coloquei os comprimentos da hipotenusa, do cateto oposto e do cateto adjascente. Para facilitar a conferência dos cálculos, eu coloquei também os ângulos theta (que alguns livros chamam de alfa) e beta já devidamente calculados.

Então, sabendo que o quadrado da hipotenusa é igual à soma dos quadrados dos catetos (Teorema de Pitógoras):

\[c^2 = a^2 + b^2\]

Tudo que temos a fazer a converter esta fórmula para código Python. Veja:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

# vamos importar o módulo Math
import math as math

def main():
  a = 20 # medida do cateto oposto
  b = 30 # medida do cateto adjascente
  
  # agora vamos calcular o comprimento da hipotenusa
  c = math.sqrt(math.pow(a, 2) + math.pow(b, 2))
 
  # e mostramos o resultado
  print("O comprimento da hipotenusa é: %f" % c)
  
if __name__== "__main__":
  main()

Ao executar este código Python nós teremos o seguinte resultado:

O comprimento da hipotenusa é: 36.055513

Como podemos ver, o resultado retornado com o código Python confere com os valores da imagem apresentada.


Python ::: Desafios e Lista de Exercícios Resolvidos ::: Fenômenos dos Transportes, Hidráulica e Drenagem

Exercício Resolvido de Python - Determine a vazão escoada em um canal com seção retangular, com lâmina d´água de 2,00m e largura de base igual a 3,00m e declividade 0,2m por Km

Quantidade de visualizações: 361 vezes
Exercício Resolvido de Python - Determine a vazão escoada em um canal com seção retangular, com lâmina d'água de 2,00m e largura de base igual a 3,00m e declividade 0,2m por Km

Pergunta/Tarefa:

Python para Fenômenos dos Transportes, Hidráulica e Drenagem. Python para cálculo de vazão em condutos livres. Fórmula de Manning para a velocidade de escoamento.

Neste exercício em Python veremos como calcular a vazão de um canal com seção retangular. Para isso nós vamos usar a Equação de Manning da velocidade do escoamento.

Determine a vazão escoada em um canal com seção retangular, com lâmina d'água de 2,00m e largura de base igual a 3,00m e declividade 0,2m por Km. Utilize &#951;=0,012.



Sua saída deverá ser parecida com:

Informe a Largura da Base do Canal (em metros): 3
Informe a Profundidade do Escoamento (em metros): 2
Informe a Declividade do Canal (em metros por km): 0.2
Informe o Coeficiente de Rugosidade do Canal: 0.012

A Área Molhada do Canal é: 6.0 m2
O Perímetro Molhado do Canal é: 7.0 m
O Raio Hidráulico do Canal é: 0.8571428571428571 m
A Velocidade do Escoamento é: 1.0634144533132281 m/s
A Vazão do Canal é: 6.380486719879369 m3/s
Resposta/Solução:

Veja a resolução completa para o exercício em Python, comentada linha a linha:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

# vamos importar o módulo Math
import math

# método principal
def main():
  # vamos ler a largura do canal em metros
  b = float(input("Informe a Largura da Base do Canal (em metros): "))

  # vamos ler a profundida do escoamento em metros
  h = float(input("Informe a Profundidade do Escoamento (em metros): "))
  
  # vamos obter a declividade do canal em metros por quilômetros
  I = float(input("Informe a Declividade do Canal (em metros por km): "))
  # vamos converter a declividade em metro por metro
  I = I / 1000.0

  # vamos ler o coeficiente de rugosidade do canal
  n = float(input("Informe o Coeficiente de Rugosidade do Canal: "))

  # vamos calcular a área molhada
  am = b * h

  #  agora vamos calcular o perímetro molhado
  pm = b + 2 * h

  # finalmente calculamos o raio hidráulico
  rh = am / pm

  # agora vamos usar a equação de manning para calcular a velocidade do escoamento
  v = math.pow(rh, 2.0 / 3.0) * (math.sqrt(I) / n)

  # finalmente calculamos a vazão do canal
  Q = am * v

  # e mostramos os resultados
  print("\nA Área Molhada do Canal é: {0} m2".format(am))
  print("O Perímetro Molhado do Canal é: {0} m".format(pm))
  print("O Raio Hidráulico do Canal é: {0} m".format(rh))
  print("A Velocidade do Escoamento é: {0} m/s".format(v))
  print("A Vazão do Canal é: {0} m3/s".format(Q))

if __name__== "__main__":
  main()



Python ::: Dicas & Truques ::: Data e Hora

Python para iniciantes - Como obter o ano com quatro dígitos usando Python

Quantidade de visualizações: 7572 vezes
Em algumas situações nós precisamos obter apenas o ano de uma determinada data, e com quatro dígitos. Para isso só precisamos passar o indicador "%Y" para a função strftime() da linguagem Python.

Veja o exemplo completo:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

from datetime import datetime

# função principal do programa
def main():
  # Obtém um datetime da data e hora atual
  hoje = datetime.today()
 
  # Exibe o ano com quatro dígitos
  print(hoje.strftime("O ano é: %Y"))
  
if __name__== "__main__":
  main()

Ao executarmos este código nós teremos o seguinte resultado:

O ano é: 2021


Vamos testar seus conhecimentos em Python

Analise o seguinte código Python

a = {5, 8, 2, 1}
b = {1, 4, 5, 3}
c = a & b
print(c)

Qual é o resultado de sua execução?

A) {5, 5, 1, 1}

B) Um erro de execução na linha 2

C) {1, 5}

D) {5, 8, 2, 1, 1, 4, 5, 3}
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em Ética e Legislação Profissional

Responsabilidade civil dos prepostos e preponentes

Com relação as definições do preposto, assinale a alternativa correta.

A) O preposto pode negociar por conta própria ou de terceiro, e participar indiretamente de operação idêntica a que lhe foi cometida.

B) O preposto não pode, sem autorização escrita, fazer-se substituir no desempenho da preposição, sob pena de responder pessoalmente pelos atos do substituto e pelas obrigações por ele contraídas.

C) Considera-se inválida a entrega de papéis, bens ou valores ao preposto, encarregado pelo preponente, se este os recebeu sem protesto.

D) As limitações contidas na outorga de poderes podem ser opostas a terceiros, dependem do arquivamento e averbação do instrumento no Registro Público de Empresas Mercantis.

E) No exercício de suas funções, os prepostos são pessoalmente responsáveis, perante terceiros, pelos atos culposos e atos dolosos.
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em

Materiais de construção

Se colocarmos um tijolo na água, ele sairá molhado por ter a característica de absorver água. Tal característica ocorre em função de uma propriedade do tijolo. Que propriedade é essa?

A) Maleabilidade.

B) Porosidade.

C) Desgaste.

D) Ductilidade.

E) Dureza.
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em

Dimensionamento de lajes maciças à flexão

As lajes de concreto armado são elementos planos e horizontais, submetidos a carregamentos perpendiculares ao plano. Esses carregamentos promovem o desenvolvimento de esforços internos de flexão.

Analise as afirmativas a seguir referentes aos tipos de flexão:

I. A flexão normal ocorre em uma seção transversal em que atuam apenas momento fletor e esforço normal de tração ou compressão.

II. A flexão reta ocorre quando os momentos fletores atuam em planos ortogonais aos eixos principais de inércia da seção transversal.

III. Diz-se que a seção transversal de uma laje está submetida à flexão pura quando sobre ela atuam somente momentos fletores.

IV. A seção transversal de uma laje está submetida à flexão composta quando, sobre esta, atuam momentos de flexão e forças normais.

Assinale a alternativa correta:

A) Apenas a afirmativa I está correta.

B) Apenas a afirmativa III está correta.

C) As afirmativas I, II e IV estão corretas.

D) As afirmativas II, III e IV estão corretas.

E) As afirmativas I, II, III e IV estão corretas.
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em JavaScript

Analise o seguinte código JavaScript

const numeros = [33, 2, 8]; 
numeros.sort();
document.write(numeros[1]);

Qual é o resultado de sua execução?

A) 2

B) 8

C) 1

D) 33
Verificar Resposta Estudar Cards Todas as Questões

Desafios, Exercícios e Algoritmos Resolvidos de Python

Veja mais Dicas e truques de Python

Dicas e truques de outras linguagens

E-Books em PDF

E-Book 650 Dicas, Truques e Exercícios Resolvidos de Python - PDF com 1.200 páginas
Domine lógica de programação e a linguagem Python com o nosso E-Book 650 Dicas, Truques e Exercícios Exercícios de Python, para você estudar onde e quando quiser.

Este e-book contém dicas, truques e exercícios resolvidos abrangendo os tópicos: Python básico, matemática e estatística, banco de dados, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book
E-Book 350 Exercícios Resolvidos de Java - PDF com 500 páginas
Domine lógica de programação e a linguagem Java com o nosso E-Book 350 Exercícios Exercícios de Java, para você estudar onde e quando quiser.

Este e-book contém exercícios resolvidos abrangendo os tópicos: Java básico, matemática e estatística, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: C
6º lugar: Delphi
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby



© 2025 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 30 usuários muito felizes estudando em nosso site.