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: Lisp ::: Dicas & Truques ::: Arrays e Matrix (Vetores e Matrizes)

Como criar um array unidimensional em LISP preenchido com um determinado valor usando make-array e :initial-element

Quantidade de visualizações: 554 vezes
Em algumas situações nós precisamos criar um vetor (um array unidimensional) na linguagem LISP e gostaríamos de preencher os seus elementos com o mesmo valor, ou seja, um array de 0s, 1s, -1s, etc. Para isso podemos combinar a função make-array e o argumento :initial-element.

Veja um código LISP no qual criamos um array unidimensional de 10 elementos, todos preenchidos com o valor 3:

----------------------------------------------------------------------
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 criar um array unidimensional contendo
; espaço para 10 elementos
(let (numeros)
  ; agora que já declaramos o nome do array,
  ; vamos reservar espaço para os 10 elementos
  ; todos preenchidos com o valor 3
  (setq numeros (make-array '(10) :initial-element 3))
  ; vamos mostrar o array criado
  (format t "Os elementos do array são: ~D~%"
    numeros)  
)

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

Os elementos do array são: #(3 3 3 3 3 3 3 3 3 3)

Link para compartilhar na Internet ou com seus amigos:

Lisp ::: Desafios e Lista de Exercícios Resolvidos ::: Lisp Básico

Exercícios Resolvidos de Lisp - Como multiplicar dois números em Lisp - Escreva um programa em Lisp para ler dois números inteiros informados

Quantidade de visualizações: 1687 vezes
Exercício Resolvido de Lisp - Como multiplicar dois números em Lisp - Escreva um programa em Lisp para ler dois números inteiros informados

Pergunta/Tarefa:

Escreva um programa Common Lisp que solicita ao usuário dois números inteiros e mostre a multiplicação dos dois valores, ou seja, o primeiro valor multiplicado pelo segundo.

Sua saída deverá ser parecida com:

Informe o primeiro valor: 3
Informe o segundo valor: 7
3 vezes 7 é 21
Resposta/Solução:

Veja a resolução completa para o exercício em Common Lisp usando o compilador Steel Bank Common Lisp (SBCL), 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 definir as variáveis que vamos
; usar no programa
(defvar n1)
(defvar n2)
(defvar produto)

; Este o programa principal
(defun Multiplicacao()
  ; Vamos ler o primeiro valor
  (princ "Informe o primeiro valor: ")
  ; talvez o seu compilador não precise disso
  (force-output)
  (setq n1 (read))
  ; Vamos ler o segundo valor
  (princ "Informe o segundo valor: ")
  ; talvez o seu compilador não precise disso
  (force-output)
  (setq n2 (read))
  
  ; Agora vamos efetuar a multiplicação dos
  ; dois valores informados
  (setq produto (* n1 n2))
  
  ; E mostramos o resultado
  (format t "~D vezes ~D é ~D" n1 n2
    produto)
)

; Auto-executa a função Multiplicacao()
(Multiplicacao)



Lisp ::: Desafios e Lista de Exercícios Resolvidos ::: Lisp Básico

Exercícios Resolvidos de Lisp - Como somar dois números em Lisp - Escreva um programa Lisp que leia dois números e mostre a sua soma

Quantidade de visualizações: 1508 vezes
Exercício Resolvido de Lisp - Como somar dois números em Lisp - Escreva um programa Lisp que leia dois números e mostre a sua soma

Pergunta/Tarefa:

Escreva um programa Common Lisp que solicita ao usuário dois números inteiros e mostre a sua soma.

Sua saída deverá ser parecida com:

Informe o primeiro valor: 2
Informe o segundo valor: 8
A soma é 10
Resposta/Solução:

Veja a resolução completa para o exercício em Common Lisp usando o compilador Steel Bank Common Lisp (SBCL), 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 definir as variáveis que vamos
; usar no programa
(defvar n1)
(defvar n2)
(defvar soma)

; Este o programa principal
(defun Soma()
  ; Vamos ler o primeiro valor
  (princ "Informe o primeiro valor: ")
  ; talvez o seu compilador não precise disso
  (force-output)
  (setq n1 (read))
  ; Vamos ler o segundo valor
  (princ "Informe o segundo valor: ")
  ; talvez o seu compilador não precise disso
  (force-output)
  (setq n2 (read))
  
  ; Agora vamos efetuar a soma dos dois números
  (setq soma (+ n1 n2))
  
  ; E mostramos o resultado
  (format t "A soma é ~D" soma)
)

; Auto-executa a função Soma()
(Soma)



Lisp ::: LISP para Engenharia ::: Geometria Analítica e Álgebra Linear

Como converter Coordenadas Polares para Coordenadas Cartesianas em LISP - LISP para Engenharia

Quantidade de visualizações: 654 vezes
Nesta nossa série de LISP e AutoLISP 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 LISP 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 
----------------------------------------------------------------------

; programa LISP que converte Coordenadas Polares
; em Coordenadas Cartesianas
(let((raio)(theta)(graus)(x)(y))
  ; vamos ler o raio e o ângulo
  (princ "Informe o raio: ")
  (force-output)
  (setq raio (read))
  (princ "Informe o theta: ")
  (force-output)
  (setq theta (read))
  (princ "Theta em graus (1) ou radianos (2): ")
  (force-output)
  (setq graus (read))
  
  ; o theta está em graus?
  (if(eq graus 1)
    (setq theta (* theta (/ pi 180.0)))    
  )
  
  ; fazemos a conversão para coordenadas cartesianas 
  (setq x (* raio (cos theta)))
  (setq y (* raio (sin theta)))
  
  ; exibimos o resultado
  (format t "As Coordenadas Cartesianas são: (x = ~F, y = ~F)"
    x y)
)

Ao executar este código LISP 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)


Lisp ::: Fundamentos da Linguagem ::: Variáveis e Constantes

Como declarar variáveis globais em Lisp usando as funções defvar e defparameter

Quantidade de visualizações: 921 vezes
Em algumas situações nós precisamos declarar variáveis globais em Lisp, ou melhor, em Common Lisp, que é a padronização da Lisp que adotamos para estas dicas.

Variáveis globais em Common Lisp se comportam de forma idêntica àquelas de outras linguagens de programação, ou seja, possuem valores permanentes por todo o sistema Lisp e mantém seus valores até que novos valores são especificados.

Se quisermos, por exemplo, a partir do corpo de uma função acessar uma variável fora dela, então esta variável deverá ser declarada globalmente.

Em Common List nós podemos declarar variáveis globais usando as funções defvar e defparameter. Vamos ver exemplos envolvendo as duas e no final desta dica eu mostro a diferença.

Veja um trecho de código Common Lisp na qual declaramos uma variável global chamada valor e a acessamos de dentro de uma função:

----------------------------------------------------------------------
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 declarar uma variável global
(defvar valor 10)

; vamos mostrar o valor atual da variável global
(format t "O valor da variável global é ~D" valor)

; agora vamos acessar a variável global
; de dentro de uma função
(defun ModificaValor()
  ; vamos alterar o valor da variável global
  (setq valor 50)
)

; chamamos a função ModificaValor
(ModificaValor)

; e checamos se o valor da variável global foi
; mesmo alterado
(terpri)
(format t "O valor da variável global é ~D" valor)

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

O valor da variável global é 10
O valor da variável global é 50

Veja agora um trecho de código Common Lisp no qual usamos a função defparameter para declarar e inicializar as variáveis globais:

----------------------------------------------------------------------
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 declarar três variáveis globais
(defparameter *a* 5)
(defparameter *b* 3)
(defparameter *soma* 0)

; agora vamos acessar as variáveis globais
; de dentro de uma função
(defun Somar()
  ; vamos somar as duas variáveis globais
  ; e guardar o resultado em uma terceira
  ; variáveis global
  (setq *soma* (+ *a* *b*))
)

; chamamos a função Somar
(Somar)

; e mostramos o resultado da soma
(format t "A soma das variáveis globais é ~D" *soma*)

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

A soma das variáveis globais é 8

Note que coloquei asteríscos (*) ao redor dos nomes das variáveis globais. Esta é uma prática comum entre programadores Lisp e altamente recomendado pelo comunidade, pois facilita a distinção entre variáveis globais e locais.

Então, qual é a diferença entre defvar e defparameter?

A primeira delas é que a função defparameter nos obriga a informar o valor inicial para a variável global, enquanto a função defvar não o faz.

A segunda diferença é que, ao redefinirmos o valor de uma variável global usando defparameter, o valor armazenado anteriormente será sobreposto, enquanto a função defvar não altera o valor anterior.


Lisp ::: Fundamentos da Linguagem ::: Estruturas de Controle

Como usar o laço loop for da linguagem Lisp

Quantidade de visualizações: 642 vezes
O laço for loop da linguagem Common Lisp é usado quando sabemos exatamente quantas vezes uma instrução ou um grupo de instruções deve ser repetido. Este laço é similar ao laço for encontrado na maioria das linguagens de programação.

Vamos começar vendo um laço for loop que conta de 1 até 10:

----------------------------------------------------------------------
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 
----------------------------------------------------------------------

; Um laço for loop que conta de 1 até 10
(loop for i from 1 to 10
  do (print i)
)

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

1
2
3
4
5
6
7
8
9
10

Agora veja o mesmo laço usado para contar de 10 até 1, ou seja, em ordem decrescente:

----------------------------------------------------------------------
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 
----------------------------------------------------------------------

; Um laço for loop que conta de 10 até 1
(loop for i from 10 downto 1
  do (print i)
)

Note que, agora, eu troquei "to" por "downto" para que a variável de controle fosse decrementada, em vez de incrementada. Dessa forma, ao executarmos este código Common Lisp, o resultado será:

10
9
8
7
6
5
4
3
2
1


Lisp ::: Fundamentos da Linguagem ::: Variáveis e Constantes

Como declarar variáveis locais em Lisp usando o comando let

Quantidade de visualizações: 743 vezes
Em várias situações nós gostaríamos de declarar variáveis que serão usadas em um espaço limitado, ou seja, dentro de uma função Common Lisp ou até mesmo em um bloco de código. Entram em cena as variáveis locais.

Variáveis locais, como o próprio nome indica, são visíveis apenas dentro do corpo de uma função ou dentro do bloco no qual elas são declaradas.

Em Common Lisp as variáveis locais são declaradas usando-se o comando let. Veja um exemplo no qual nós declaramos três variáveis locais e que serão usadas no corpo de uma função Multiplicar():

----------------------------------------------------------------------
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 definir a função Multiplicar()
(defun Multiplicar()
  ; vamos usar o comando let para declarar
  ; três variáveis locais
  (let ((a 3)(b 9)(produto))
    ; agora vamos obter o produto das variáveis
    ; a e b
    (setq produto (* a b))
    ; e mostramos o resultado
    (format t "O produto dos dois valores é ~D" produto)
  )
)

; chamamos a função Multiplicar()
(Multiplicar)

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

O produto dos dois valores é 27

Agora veja como podemos declarar variáveis locais dentro de um bloco de código em Common Lisp:

----------------------------------------------------------------------
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 usar o comando let para declarar
; três variáveis locais (dentro de um bloco
; de código)
(let ((a 7)(b 5)(produto))
  ; agora vamos obter o produto das variáveis
  ; a e b
  (setq produto (* a b))
  ; e mostramos o resultado
  (format t "O produto dos dois valores é ~D" produto)
)

Execute este código e você terá o seguinte resultado:

O produto dos dois valores é 35

Nos dois trechos de código, se tentarmos acessar as variáveis locais fora de seus escopos, nós teremos o seguinte erro:

The variable PRODUTO is unbound.


Lisp ::: Desafios e Lista de Exercícios Resolvidos ::: Lisp Básico

Exercícios Resolvidos de Lisp - Como calcular a soma, o produto, a diferença e o quociente de dois números inteiros informados pelo usuário

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

Escreva um programa Common Lisp que pede para o usuário informar dois número inteiros. Em seguida mostre a soma, o produto, a diferença e o quociente dois dois números informados.

Sua saída deverá ser parecida com:

Informe o primeiro número: 8
Informe o segundo número: 3
A soma dos números é: 11
O produto dos números é: 24
A diferença dos números é: 5
O quociente dos números é: 2.66667
Resposta/Solução:

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

----------------------------------------------------------------------
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 
----------------------------------------------------------------------

; Este é o programa principal
(defun Exercicio()
  ; Variáveis usadas na resolução do problema
  (let ((n1)(n2)(soma)(produto)
    (diferenca)(quociente))
    ; Vamos ler os dois números
    (princ "Informe o primeiro número: ")
    ; talvez o seu compilador não precise disso
    (force-output)
    ; atribui o valor lido à variável n1
    (setq n1 (read))
    (princ "Informe o segundo número: ")
    ; talvez o seu compilador não precise disso
    (force-output)
    ; atribui o valor lido à variável n2
    (setq n2 (read))
  
    ; vamos somar os dois números
    (setq soma (+ n1 n2))
    ; vamos calcular o produto
    (setq produto (* n1 n2))
    ; vamos calcular a diferença
    (setq diferenca (- n1 n2))
    ; vamos calcular o quociente
    (setq quociente (/ n1 (* n2 1.0)))
  
    ; E mostramos o resultado
    (format t "A soma dos números é ~D" soma)
    (format t "~%O produto dos números é ~D" produto)
    (format t "~%A diferença dos números é ~D" diferenca)
    (format t "~%O quociente dos números é ~F" quociente)	
  )
)

; Auto-executa a função Exercicio()
(Exercicio)



Lisp ::: Fundamentos da Linguagem ::: Estruturas de Controle

Como usar o laço loop para contar de 1 até 10 em Lisp

Quantidade de visualizações: 650 vezes
A estrutura de repetição loop da linguagem Common Lisp é o laço mais simples fornecido pela linguagem. Este laço nos permite repetir uma ou mais instruções de código repetidamente, até que o comando return seja encontrado, o que faz com que o laço seja interrompido.

Veja no trecho de código abaixo como podemos usar o laço loop da Common Lisp para contar e exibir os valores de 1 até 10:

----------------------------------------------------------------------
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 declarar a variável que vamos usar
  let (numero)	
  ; vamos inicializar a variável com o valor 1
  (setq numero 1)
  ; agora iniciamos o laço
  (loop 
    ; escrevemos o valor da variável
    (write numero)
    ; aumentamos o valor da variável em 1
    (setq numero (+ numero 1))
    ; provocamos uma quebra de linha 
    (terpri)
    ; e fazemos o teste da continuidade
    (when (> numero 10) (return))
  )
)

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

1
2
3
4
5
6
7
8
9
10

Veja que usamos a macro when para testar o ponto de parada do laço. Note ainda o uso da função terpri da Common Lisp para provocar uma quebra de linha na saída do programa.


Vamos testar seus conhecimentos em Fundações

Fundações diretas ou rasas

As fundações diretas ou rasas são utilizadas em situações em que as camadas do solo sejam resistentes de forma suficiente para suportar as cargas da estrutura. Elas tornam possível a transmissão dessas cargas diretamente ao solo, pela base da fundação, que é dimensionada de forma a distribuir o peso da construção no solo para que a pressão sobre ele seja compatível com a sua resistência. Analise as sentenças a respeito das fundações rasas ou diretas:

I - Transferem as cargas das estruturas para camadas subsuperficiais da terra.

II - Em uma mesma edificação, é possível encontrar mais do que dois tipos diferentes de fundações, mesmo que sejam rasas ou profundas.

III - O uso de fundações rasas será considerado uma técnica adequada quando o número de golpes do SPT for maior ou igual a 8 e a profundidade não ultrapassar 2m.

Qual(is) está(ão) correta(s)?

A) II.

B) I.

C) II e III.

D) I e III.

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

Vamos testar seus conhecimentos em JavaScript

Como arredondar o valor 7.25 para o inteiro mais próximo em JavaScript?

A) Math.rnd(7.25)

B) Math.round(7.25)

C) rnd(7.25)

D) round(7.25)
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em

Segurança e Estados Limites Ações nas Estruturas de Concreto Armado

O dimensionamento de elementos estruturais deve ser realizado considerando os critérios de segurança estabelecidos pela NBR 6118/2023 (Projeto de estruturas de concreto), especificamente relacionados ao ELS e ao ELU.

Com relação aos estados limites e aos critérios de segurança das edificações, assinale a resposta correta.

A) As combinações do ELS são utilizadas para o dimensionamento das estruturas ao colapso.

B) As deformações são analisadas somente nos ELS.

C) Para combinações no ELU, o valor característico da resistência do concreto armado deve ser superior ao valor de cálculo das solicitações.

D) Para verificações de ELS, o valor de cálculo da combinação das ações deve ser inferior ao valor limite adotado para seu efeito.

E) Os valores de combinações no ELS serão sempre superiores às combinações no ELU.
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em Engenharia Civil - Instalações Hidráulicas Prediais

Sistema domiciliar de abastecimento de água

Se alguém mergulha numa piscina, a água exerce uma pressão sobre o corpo. Da mesma forma, a água exerce uma pressão sobre outros fluidos ou sobre uma superfície. Essa pressão não depende do volume de água contido em determinado recipiente, mas da altura do nível da água.

Assim, ao se dimensionar as tubulações, deve-se considerar as pressões máximas e mínimas que serão suportadas pelas tubulações. Dessa forma, a pressão máxima que a instalação de água fria pode apresentar durante o funcionamento dos aparelhos é:

Selecione a resposta:

A) 0,5mca.

B) 60mca.

C) 20mca.

D) 40mca.

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

Vamos testar seus conhecimentos em

Domínios de Deformações

Vigas de concreto armado, com seções submetidas a um momento fletor e a um esforço cortante, são dimensionadas de tal forma que se determine uma armadura longitudinal para resistir ao momento fletor e uma armadura transversal para resistir ao esforço cortante.

Analise as informações a seguir, a respeito da solicitação normal do tipo momento fletor:

I) Solicitação de flexão simples ocorre quando a única solicitação atuante é o momento fletor.

II) Solicitação de flexão composta ocorre quando, além do momento fletor, há uma força normal atuante.

III) Solicitação de flexão oblíqua ocorre quando o plano de flexão compreende um eixo de simetria da seção transversal.

Assinale a alternativa correta:

A) Somente a afirmação I está correta.

B) Somente as afirmações I e II estão corretas.

C) Somente a afirmação II está correta.

D) Somente a afirmação III está correta.

E) Somente as afirmações II e III estão corretas.
Verificar Resposta Estudar Cards Todas as Questões

Veja mais Dicas e truques de Lisp

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á 24 usuários muito felizes estudando em nosso site.