Dúvidas, comentários e doaçoes: +55 62 9 8513 2505

Planilha de Dimensionamento de Tubulações Hidráulicas Água Fria e Água Quente Completa
Nossa planilha automática de dimensionamento de tubulações de água fria e quente é uma ferramenta desenvolvida para auxiliar engenheiros e projetistas no cálculo rápido e preciso das redes hidráulicas de edificaçoes. Por meio da inserçao de dados como vazao, diâmetro da tubulaçao, comprimento da rede, material do tubo e coeficientes hidráulicos, a planilha realiza automaticamente os cálculos necessários para verificar velocidade da água, perda de carga e dimensionamento adequado das tubulaçoes.

Você está aqui: Cards de Ética e Legislação Profissional
Card 1 de 8
Noções de licitação pública

Modalidades da licitação:

Convite é a modalidade dirigida para interessados do ramo do objeto da licitação e é adequado para contratações de menor valor. Na Lei n.º 14.133/2021, essa modalidade foi extinta.

Leilão é a modalidade para a venda de bens móveis que não servem mais para a administração pública, a venda de produtos legalmente apreendidos ou penhorados e para a alienação de imóveis da administração pública.

Concurso é a modalidade indicada para a escolha de um trabalho técnico, artístico ou científico.

Pregão é a modalidade de licitação para aquisição de bens e serviços comuns. No artigo 1º, parágrafo único, da Lei n.º 10.520/2002, consta que bens e serviços comuns são "aqueles cujos padrões de desempenho e qualidade possam ser objetivamente definidos pelo edital, por meio de especificações usuais no mercado". Isso significa que são bens e serviços que não têm características técnicas especiais, sendo facilmente encontrados no mercado. O pregão também foi previsto na nova lei de licitações, no artigo 28, i.

Concorrência é a modalidade indicada para contratações de grandes valores, em que o interessado precisa comprovar a qualificação exigida no edital.

Filtrar Cards
Use esta opção para filtrar os cards pelos tópicos que mais lhe interessam.
Termos:
Aviso Importante: Nos esforçamos muito para que o conteúdo dos cards e dos testes e conhecimento seja o mais correto possível. No entanto, entendemos que erros podem ocorrer. Caso isso aconteça, pedimos desculpas e estamos à disposição para as devidas correções. Além disso, o conteúdo aqui apresentado é fruto de conhecimento nosso e de pesquisas na internet e livros. Caso você encontre algum conteúdo que não deveria estar aqui, por favor, nos comunique pelos e-mails exibidos nas opções de contato.
Link para compartilhar na Internet ou com seus amigos:

C++ ::: C++ para Engenharia ::: Geometria Analítica e Álgebra Linear

Como calcular a norma ou módulo de vetores nos espaços R2 e R3 usando C++ - Geometria Analítica e Álgebra Linear usando C++

Quantidade de visualizações: 2708 vezes
Em Geometria Analítica e Álgebra Linear, a magnitude, norma, comprimento, tamanho ou módulo (também chamado de intensidade na Física) de um vetor é o seu comprimento, que pode ser calculado por meio da distância de seu ponto final a partir da origem, no nosso caso (0,0).

Considere o seguinte vetor no plano, ou seja, no espaço bidimensional, ou R2:

\[\vec{v} = \left(7, 6\right)\]

Aqui este vetor se inicia na origem (0, 0) e vai até as coordenadas (x = 7) e (y = 6). Veja sua plotagem no plano 2D:



Note que na imagem já temos todas as informações que precisamos, ou seja, o tamanho desse vetor é 9 (arredondado) e ele faz um ângulo de 41º (graus) com o eixo x positivo. Em linguagem mais adequada da trigonometria, podemos dizer que a medida do cateto oposto é 6, a medida do cateto adjacente é 7 e a medida da hipotenusa (que já calculei para você) é 9.

Note que já mostrei também o ângulo theta (__$\theta__$) entre a hipotenusa e o cateto adjacente, o que nos dá a inclinação da reta representada pelos pontos (0, 0) e (7, 6).

Relembrando nossas aulas de trigonometria nos tempos do colegial, temos que o quadrado da hipotenusa é a soma dos quadrados dos catetos, ou seja, o Teorema de Pitágoras:

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

Como sabemos que a potenciação é o inverso da radiciação, podemos escrever essa fórmula da seguinte maneira:

\[a = \sqrt{b^2 + c^2}\]

Passando para os valores x e y que já temos:

\[a = \sqrt{7^2 + 6^2}\]

Podemos comprovar que o resultado é 9,21 (que arredondei para 9). Não se esqueça da notação de módulo ao apresentar o resultado final:

\[\left|\vec{v}\right| = \sqrt{7^2 + 6^2}\]

E aqui está o código C++ que nos permite informar os valores x e y do vetor e obter o seu comprimento, tamanho ou módulo:

#include <string>
#include <iostream>
#include <math.h>
 
using namespace std;
  
int main(int argc, char *argv[]){
  float x, y, norma;
  // vamos ler os valores x e y
  cout << "Informe o valor de x: ";
  cin >> x;
  cout << "Informe o valor de y: ";
  cin >> y;
  
  // vamos calcular a norma do vetor
  norma = sqrt(pow(x, 2) + pow(y, 2));
    
  // mostra o resultado
  cout << "A norma do vetor é: " << norma; 
 
  cout << "\n\n";
  system("PAUSE");
  return 0;
}

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

Informe o valor de x: 7
Informe o valor de y: 6
A norma do vetor é: 9.219544457292887

Novamente note que arredondei o comprimento do vetor para melhor visualização no gráfico. Para calcular a norma de um vetor no espaço, ou seja, no R3, basta acrescentar o componente z no cálculo.


Python ::: NumPy Python Library (Biblioteca Python NumPy) ::: Números Aleatórios, Números Randômicos, Amostras Aleatórias, Amostras Randômicas

Como gerar um número randômico em Python usando a função rand() do módulo random da NumPy

Quantidade de visualizações: 1090 vezes
Em algumas situações nós precisamos gerar um número aleatório na faixa de 0 e 1 (não incluído). Para isso nós podemos usar a função rand() do módulo random da biblioteca NumPy do Python. Veja um exemplo:

# importamos o módulo random da biblioteca NumPy
import numpy as np

# método principal
def main():
  # vamos gerar um número decimal aleatório de 0 (incluído) 
  # à 1 (não incluído) 
  valor = np.random.rand()
  print("O número sorteado foi: {0}".format(valor)) 
  
if __name__== "__main__":
  main()

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

O número sorteado foi: 0.2037063569952866

Note que o número retornado pela função rand() é um float com uma precisão semelhante ao double em outras linguagens de programação.

Veja agora uma modificação deste código para gerar 10 números aleatórios:

# importamos o módulo random da biblioteca NumPy
import numpy as np

# método principal
def main():
  # vamos gerar 10 números decimais aleatórios de 0 (incluído) 
  # à 1 (não incluído) 
  for i in range(10):
    valor = np.random.rand()
    print("O número sorteado foi: {0}".format(valor)) 
  
if __name__== "__main__":
  main()

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

O número sorteado foi: 0.57920714427429
O número sorteado foi: 0.06329414607318185
O número sorteado foi: 0.12184477988071851
O número sorteado foi: 0.5410663009618577
O número sorteado foi: 0.790229323250604
O número sorteado foi: 0.4733277307431061
O número sorteado foi: 0.7669969432159425
O número sorteado foi: 0.6934927410217504
O número sorteado foi: 0.13216036543343856
O número sorteado foi: 0.6958612722883786


Delphi ::: Data Access Controls (Controles de Acesso a Dados) ::: TField e Classes Derivadas

Como usar a classe TField em seus programas Delphi

Quantidade de visualizações: 13168 vezes
A classe TField (na unit DB) é um ancestral comum de todos os componentes que representam os campos de uma tabela no banco de dados (ou um dataset cujos dados foram carregados de um arquivo do tipo texto, binário ou XML). Esta classe encapsula o comportamento comum a todos os demais componentes to tipo field (campo).

Veja sua posição na hierarquia de classes do Delphi:

System.TObject
  Classes.TPersistent
    Classes.TComponent
      DB.TField
Esta classe ainda implementa as interfaces Classes.IInterfaceComponentReference e System.IInterface.

A classe TField apresenta propriedades, eventos e métodos que são usados para as seguintes tarefas:

1) Alterar o valor de um campo em um dataset;

2) Converter o valor de um campo de um tipo para outro tipo;

3) Efetuar validações nos dados informados pelos usuários para determinados campos;

4) Definir como as informações dos campos são mostradas em tempo de exibição ou para edição;

5) Calcular o valor de um campo a partir de código escrito no evento OnCalcFields do dataset;

6) Pesquisar o valor do campo a partir de outro dataset.

Em geral não criamos instâncias da classe TField diretamente. Componentes que descendem de TField são criados automaticamente a cada vez que o dataset é ativado. Estes descendentes podem ser dinâmicos (o padrão) ou persistentes. Componentes campos dinâmicos refletem as colunas dos metadados da tabela a qual pertencem no momento que o dataset é aberto. Componentes campos persistentes são criados em tempo de design usando o editor Fields, que especifica os campos no dataset, suas propriedades e a ordem em que deverão estar.

A criação de componentes de campos persistentes garante que todas as vezes que uma aplicação for executada, ela usará e exibirá as mesmas colunas, na mesma ordem, até mesmo se a estrutura física da base de dados mudar. Se uma coluna em uma tabela na qual um componente de campo persistente é baseado for excluída ou alterada, o IDE gera uma exceção em vez de permitir a abertura do dataset usando um coluna não existente ou incompatível. Se isso acontecer, devemos remover o camponente field para o campo não existente usando o editor Fields.

Um campo (field) em um dataset é sempre tratado como uma das classes descendentes de TField abaixo:

        
TADTField          TDateField         TReferenceField   
TAggregateField    TDateTimeField     TSmallIntField   
TArrayField        TFloatField        TSQLTimeStampField   
TAutoIncField      TFMTBCDField       TStringField   
TBCDField          TGraphicField      TTimeField   
TBinaryField       TGuidField         TVarBytesField   
TBlobField         TIDispatchField    TVariantField   
TBooleanField      TIntegerField      TWideStringField   
TBytesField        TInterfaceField    TWordField   
TCurrencyField     TLargeintField     TDataSetField   
TMemoField     
Veja um trecho de código no qual usamos o método FieldByName() da classe TDataSet para obter uma referência a um determinado campo (field) de um ClientDataSet e usamos sua propriedade AsString para obter o valor do campo:

procedure TForm3.Button3Click(Sender: TObject);
var
  campo: TField;
begin
  // vamos obter o campo com o nome "titulo" do registro atual
  campo := ClientDataSet1.FieldByName('titulo');

  // vamos mostrar o valor do campo
  ShowMessage('O valor do campo é: ' + campo.AsString);
end;

Ao executarmos este código teremos um resultado parecido com:

"O valor do campo é: Programando em Java".

Esta dica foi escrita e testada no Delphi 2009.


Python ::: Desafios e Lista de Exercícios Resolvidos ::: NumPy Python Library

Exercício Resolvido de Python NumPy - Como somar duas matrizes usando a biblioteca NumPy do Python

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

Escreva um programa Python que usa a biblioteca NumPy para efetuar a soma de duas matrizes de mesma ordem, ou seja, mesmo número de linhas e colunas. Seu código deverá somar o primeiro elemento da matriz A com o primeiro elemento da matriz B, e assim por diante.

Sua saída deverá ser parecida com:

A primeira matriz é:
[[4 1 3]
 [9 2 5]]
A segunda matriz é:
[[ 3 10  2]
 [ 1 13  4]]
A matriz soma é:
[[ 7 11  5]
 [10 15  9]]
Resposta/Solução:

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

# vamos importar a biblioteca NumPy
import numpy as np

# função principal do programa
def main():
  # vamos criar a primeira matriz
  a = np.array([[4, 1, 3],
                [9, 2, 5]])

  # vamos criar a segunda matriz
  b = np.array([[3, 10, 2],
                [1, 13, 4]])

  # vamos somar as duas matrizes
  c = a + b
  
  # e agora mostramos o resultado
  print("A primeira matriz é:\n{0}".format(a))
  print("A segunda matriz é:\n{0}".format(b))
  print("A matriz soma é:\n{0}".format(c))

if __name__== "__main__":
  main()



Java ::: Desafios e Lista de Exercícios Resolvidos ::: Estruturas de Dados - Listas Ligadas

Exercícios Resolvidos de Java - Como inserir um nó em qualquer posição de uma lista ligada em Java - Escreva um programa Java que cria uma lista dinamicamente encadeada

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

Escreva um programa Java que cria uma lista dinamicamente encadeada (lista singularmente encadeada) e pede para o usuário inserir 5 elementos do tipo inteiro. Em seguida peça para o usuário informar um índice e um novo elemento e insira tal elemento no índice informado.

Faça a validação dos índices para que ele não saia da faixa permitida.

Sua saída deve ser parecida com:

Inserindo 5 valores na lista

Informe o 1.o valor: 8
Informe o 2.o valor: 2
Informe o 3.o valor: 4
Informe o 4.o valor: 7
Informe o 5.o valor: 3

Valores na lista: 8 -> 2 -> 4 -> 7 -> 3 -> null

Inserindo um elemento no índice k

Informe o índice desejado: 2
Informe o valor do nó: 9

Valores na lista: 8 -> 2 -> 9 -> 4 -> 7 -> 3 -> null
Resposta/Solução:

Na saída podemos ver que o índice 2 corresponde ao terceiro elemento da lista ligada. Por isso o valor 4 foi empurrado para a frente para abrir espaço para o valor 9. Se o índice 0 fosse informado, o número 8 seria empurrado para a frente e o nó com valor 9 passaria a ser o início da lista ligada.

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

package estudos;
  
import java.util.Scanner;

// classe interna usada para representar um
// nó na lista ligada
class No {
  int valor; // valor do nó
  No proximo; // aponta para o novo nó
 
  // construtor cheio da classe No
  public No(int valor, No proximo) {
    this.valor = valor;
    this.proximo = proximo;
  }
  
  // construtor vazio da classe No
  public No() {
    this.valor = 0;
    this.proximo = null;
  }
}

public class Estudos { 
  public static void main(String args[]){
    // para ler a entrada do usuário
    Scanner entrada = new Scanner(System.in);
    
    // vamos criar uma referência para o início da lista
    No inicio = null;
    
    // vamos inserir 5 valores inteiros na lista ligada
    int valor;
    System.out.println("Inserindo 5 valores na lista\n");
    for (int i = 0; i < 5; i++) {
      System.out.print("Informe o " + (i + 1) + ".o valor: ");
      valor = Integer.parseInt(entrada.nextLine());
      // vamos inserir este valor no final da lista
      inicio = inserirFinal(inicio, valor);
    }
    
    // vamos exibir os valores na lista ligada
    System.out.print("\nValores na lista: ");
    exibirLista(inicio);
    
    // vamos inserir um novo elemento no índice informado
    System.out.println("\nInserindo um elemento no índice k\n");
    System.out.print("Informe o índice desejado: ");
    int indice = Integer.parseInt(entrada.nextLine());
    
    // o índice é válido?
    if ((indice < 0) || (indice > tamanhoLista(inicio) - 1)) {
      System.out.println("O índice é inválido.");
    }
    else {
      // vamos inserir o novo nó no índice indicado
      System.out.print("Informe o valor do nó: ");
      valor = Integer.parseInt(entrada.nextLine());
      inicio = inserirIndice(inicio, indice, valor);
      
      // vamos exibir os valores na lista ligada
      System.out.print("\nValores na lista: ");
      exibirLista(inicio);
    }
  }
  
  // função que permite adicionar um nó em uma determinada
  // posição da lista ligada
  public static No inserirIndice(No inicio, int indice, int valor) {
    // vamos apontar para o nó inicial
    No atual = inicio;
    // criamos um novo nó
    No novo = criarNo(valor);
    
    // a lista ligada ainda está vazia?
    if (atual == null){
      // inicio recebe o novo nó
      inicio = novo;
    }
    else if (indice == 0) {
      // o índice é igual a 0? vamos inserir
      // o nó no início da lista ligada
      novo.proximo = inicio;
      inicio = novo;
    }
    else {
      // vamos procurar o local adequado para inserção
      // primeiro criamos um nó temporário
      No temp = new No();
      // apontamos o nó temporário para o início da lista
      temp = inicio;
      // e percorremos os nós até encontrar a posição
      // de inserção
      for(int i = 1; i < indice; i++) {
        if (temp != null) {
          // passa para o próximo nó
          temp = temp.proximo;
        }
      }
   
      // concluimos a inserção
      novo.proximo = temp.proximo;
      temp.proximo = novo;
    }
    
    // e retornamos o início da lista
    return inicio;
  }

  // função que permite adicionar um nó no final da
  // lista ligada
  public static No inserirFinal(No inicio, int valor) {
    // vamos apontar para o nó inicial
    No atual = inicio;
    // criamos um novo nó
    No novo = criarNo(valor);
  
    // a lista ligada ainda está vazia?
    if (atual == null){
      // inicio recebe o novo nó
      inicio = novo;
    }    
    else { // temos um ou mais nós na lista ligada
      // vamos localizar o último nó
      while (atual.proximo != null) {
        atual = atual.proximo;
      }
       
      // encontramos o último nó. Agora vamos inserir
      // o novo nó depois dele
      atual.proximo = novo;
    }
     
    // e retornamos o início da lista
    return inicio;
  }
  
  // função usada para construir e retornar um novo nó
  public static No criarNo(int valor) {
    // cria o novo nó
    No no = new No(valor, null);
    // retorna o nó criado
    return no;
  }
  
  // função usada para percorrer a lista ligada e
  // exibir os valores contidos em seus nós
  public static void exibirLista(No inicio) {
    // vamos apontar para o início da lista
    No temp = inicio;
    
    // a lista está vazia?
    if (temp == null) {
      System.out.println("A lista está vazia.");
    }
    else {
      // esse laço se repete enquanto tempo for
      // diferente de null
      while (temp != null) {
        // vamos mostrar o valor desse nó
        System.out.print(temp.valor + " -> ");
        // avança para o próximo nó
        temp = temp.proximo;
      }
    
      // mostra o final da lista
      System.out.println("null");
    }
  }
  
  // função que retorna a quantidade de nós na lista ligada
  public static int tamanhoLista(No inicio) {
    int tamanho = 0;
    
    // vamos apontar para o início da lista
    No temp = inicio;
    
    // a lista está vazia?
    if (temp == null) {
      return 0;
    }
    else {
      // esse laço se repete enquanto tempo for
      // diferente de null
      while (temp != null) {
        // vamos incrementar o tamanho
        tamanho++;
        // avança para o próximo nó
        temp = temp.proximo;
      }
    }
    
    return tamanho;
  }
}



Mais Desafios de Programação e Exercícios e Algoritmos Resolvidos de Java

Veja mais Dicas e truques de Java

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


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 Apenas R$ 32,90

Planilha Web - Planilhas e Calculadoras online para estudantes e profissionais de Engenharia Civil, Engenharia Elétrica e Engenharia Mecânica.


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