Você está aqui: Java ::: Desafios e Lista de Exercícios Resolvidos ::: Física - Pesos e Medidas |
Como calcular a massa da Terra em Java - Um método Java que retorna a massa da Terra em kg - Exercícios Resolvidos de JavaQuantidade de visualizações: 459 vezes |
Pergunta/Tarefa: Este desafio de programação testa a sua habilidade em usar notação científica em Java. Sabendo-se que a massa da Terra é 5,972 x 1024 kg, escreva um método Java chamado getMassaTerra() que não aceita nenhum argumento e retorna um valor double equivalente à massa da terra em kg. Sua saída deverá ser parecida com: A massa da Terra é: 5.972E24 kg Veja a resolução comentada deste exercício usando Java: ---------------------------------------------------------------------- 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 ---------------------------------------------------------------------- package estudos; public class Estudos { public static void main(String[] args) { // vamos testar o método getMassaTerra() double massa_terra = getMassaTerra(); System.out.println("A massa da Terra é: " + massa_terra + " kg"); } // método Java que retorna a massa da Terra em kg public static double getMassaTerra() { // retorna a massa da Terra double massa = 5.972 * Math.pow(10, 24); // é possível colocar também o valor 5.972E24 direto, // sem a necessidade de usar a função Math.pow() return massa; } } |
![]() |
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Exceções e Tratamentos de Erros |
Exceções e Tratamentos de Erros - Exercícios Resolvidos de Java - Ex. 1 - Forçando o usuário a informar dois inteiros válidos antes de efetuar sua somaQuantidade de visualizações: 3160 vezes |
Pergunta/Tarefa: Escreva um programa Java que usa tratamento de erros try...catch para forçar o usuário a informar dois valores inteiros válidos antes de tentar somá-los. Caso o usuário informe um ou os dois valores inválidos, o programa deverá exibir uma mensagem de erro e solicitar os valores novamente. Sua saída deverá ser parecida com: ![]() Resposta/Solução: Veja a resolução comentada deste exercício usando Java console: ---------------------------------------------------------------------- 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 ---------------------------------------------------------------------- package estudos; import java.util.Scanner; public class Estudos { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); boolean validos = false; // para verificar se os valores são inteiros válidos int n1, n2, soma; // solicita que o usuário informe os dois valores while(!validos){ try { System.out.print("Informe o primeiro valor: "); n1 = Integer.parseInt(entrada.nextLine()); // tenta fazer a conversão System.out.print("Informe o segundo valor: "); n2 = Integer.parseInt(entrada.nextLine()); // tenta fazer a conversão // se chegou até aqui é porque não houve erros na conversão, ou seja, o usuário // informou inteiros válidos soma = n1 + n2; System.out.println("A soma dos valores é: " + soma); validos = true; } catch (Exception ex) { // houve erro na conversão? System.out.println("Dados inválidos: " + ex.toString()); System.out.println("Por favor, informe os dois números novamente"); } } } } |
Java ::: Dicas & Truques ::: Expressões Regulares |
Como usar expressões regulares em Java - Expressões regulares para iniciantesQuantidade de visualizações: 48591 vezes |
O suporte a expressões regulares ou regex tem sido parte da plataforma Java desde a versão 1.4. Contidas no pacote java.util.regex, as classes regex suportam a comparação de padrões de forma similar à linguagem Perl, mas, usando classes e a sintáxe da linguagem Java. Todo o pacote se limita a três classes: Pattern, Matcher e PatternSyntaxException. A versão 1.5 introduziu a interface MatchResult. Use as duas classes Pattern e Matcher juntas. Defina e expressão regular com a classe Pattern. Então use a classe Matcher para verificar o padrão em relação à fonte de entrada. Uma exceção é lançada quando o padrão tem um erro de sintáxe na expressão. Estas classes não possuem construtores. Em vez disso, compilamos uma expressão regular para obter um padrão, e então usamos o Pattern retornado para obter seu Matcher baseado na fonte de entrada: Pattern pattern = Pattern.compile(<regular expression>); Matcher matcher = pattern.matcher(<input source>); Uma vez que tenhamos um Matcher, tipicamente processamos a fonte de entrada a fim de encontrarmos as similaridades contidas. Usa-se o método find() para localizar similaridades do padrão na fonte de entrada. Cada chamada a find() continua a partir do ponto onde a última chamada parou, ou na posição 0 para a primeira chamada. As similaridades encontradas são retornadas pelo método group(): ---------------------------------------------------------------------- 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 ---------------------------------------------------------------------- while(matcher.find()){ System.out.printf"Found: \"%s\" from %d to %d.%n", matcher.group(), matcher.start(), matcher.end()); } O código a seguir mostra um programa básico de expressões regulares, que pede ao usuário que informe tanto a expressão regular quanto a string que será comparada: ---------------------------------------------------------------------- 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 ---------------------------------------------------------------------- import java.util.regex.*; import java.io.*; public class Regex{ public static void main(String args[]){ Console console = System.console(); // Obtém a expressão regular String regex = console.readLine("%nInforme a expressão: "); Pattern pattern = Pattern.compile(regex); // Obtém a entrada String source = console.readLine("Informe a entrada: "); Matcher matcher = pattern.matcher(source); // Mostra as similaridades while(matcher.find()){ System.out.printf("Encontrado: \"%s\" de %d à %d.%n", matcher.group(), matcher.start(), matcher.end()); } } } Mas, o que realmente é uma expressão regular? A classe Pattern fornece detalhes mais profundos, mas, basicamente uma expressão regular é uma sequência de caracteres que tenta encontrar semelhanças em outra sequencia de caracteres. Por exemplo, podemos procurar o padrão literal de "eles" duplos "ll" na string "Hello, World". O programa anterior encontraria o padrão "ll" começando na posição 2 e terminando na posição 4. A posição final é a posição do próximo caractere depois do fim do padrão de semelhança. Strings de padrão como "ll" não são muito interessantes, relatando somente onde elas estão literalmente na fonte de entrada. Padrões de expressões regulares podem incluir meta-caracteres especiais. Meta-caracteres fornecem habilidades poderosas de comparação. É possível usar os 15 caracteres "([{\^-$|]})?*+." como meta-caracteres em expressões regulares. Alguns meta-caracteres indicam o agrupamento de caracteres. Por exemplo, os caracteres de colchetes [ e ] permitem especificar um grupo de caracteres nos quais uma similaridade ocorre se qualquer um dos caracteres entre colchetes for encontrado no texto. Por exemplo, o padrão "co[cl]a" retornará similaridade com "coca" e "cola". Ele não se igualará a "cocla", uma vez que [] é usado para igualar apenas um caractere. Veremos mais sobre quantificadores mais adiante, quando quisermos encontrar alguma coisa múltiplas vezes. Além de tentar encontrar caracteres individuais, podemos usar os colchetes [ e ] para igualar uma faixa de caracteres, tais como as letras de j-z, definidas como [j-z]. Isso pode também ser combinado com um literal string, como em "foo[j-z]" que encontraria "fool", mas não encontraria "food", uma vez que l está na faixa de j à z e d não está. Podemos também usar o caractere ^ para representar negação, com um literal string ou uma faixa. O padrão "foo[^j-z]" encontrará palavras que começam como foo mas que não terminem com uma letra de j à z. Assim a string food agora seria encontrada. Faixas múltiplas podem ser combinadas como em [a-zA-Z] para informar as letras de a à z maiúsculas ou minúsculas. Enquanto literais strings são ótimos como primeira lição sobre expressões regulares, as coisas mais típicas que a maioria das pessoas usam em expressões regulares são as classes de caracteres pré-definidos. É aqui que os meta-caracteres . e \ são importantes. O ponto . é usado para representar qualquer caractere. Assim, a expressão regular ".oney" encontraria money e honey, e qualquer outro conjunto de 5 caracteres que terminem em oney. O caractere \ por sua vez, é usado com outros caracteres para representar um conjunto completo de letras. Por exemplo, enquanto podemos usar [0-9] para representar um conjunto de dígitos, podemos também usar \d. Podemos ainda usar [^0-9] para representar um conjunto de caracteres que não sejam dígitos. Ou podemos usar o caractere \D. Todas estas strings de classes de caracteres são definidas na documentação da plataforma Java para a classe Pattern, uma vez que elas não são fáceis de serem lembradas. Eis aqui um sub-conjunto de algumas classes de caracteres pré-definidos especiais: * \s -- whitespace (espaço em branco) * \S -- non-whitespace (não seja espaço em branco) * \w -- word character [a-zA-Z0-9] (caractere de palavra) * \W -- non-word character (não caractere de palavra) * \p{Punct} -- punctuation (pontuação) * \p{Lower} -- lowercase [a-z] (minúsculas) * \p{Upper} -- uppercase [A-Z] (maiúsculas) Se você quiser usar uma destas strings no programa Regex mostrado acima, você as define como mostrado. \s se iguala ao espaço em branco. Se, contudo, você quiser definir a expressão regular via código, você precisa se lembrar que o caractere \ tem tratamento especial. Devemos escapar a string no código fonte: ---------------------------------------------------------------------- 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 ---------------------------------------------------------------------- String regexString = "\\s"; Aqui, os caracteres \\ representam uma única barra invertida na string. Há outras strings especiais para representar literais strings: * \t -- tab (tabulação) * \n -- newline (nova linha) * \r -- carriage return (retorno de carro) * \xhh -- hex character 0xhh (caractere hexadecimal) * \uhhhh -- hex character 0xhhhh (caractere hexadecimal) Os quantificadores tornam as expressões regulares mais interessantes, pelo menos quando combinados com outras expresssões tais como classes de caracteres. Por exemplo, se quisermos encontrar uma string de três caracteres de a-z, poderíamos usar o padrão "[a-z][a-z][a-z]". Mas não precisamos fazer isso. Em vez de repetir a string, adicionamos um quantificador após o padrão. Para este exemplo específico, "[a-z][a-z][a-z]" pode ser representado como "[a-z]{3}". Para uma quantidade específica, o número vai dentro das chaves {}. Podemos também usar ?, * ou + para representar zero ou uma vez, zero ou mais vezes, ou uma ou mais vezes, respectivamente. O padrão [a-z]? encontra um caractere de a-z zero ou uma vez. O padrão [a-z]* encontra um caractere de a-z zero ou mais vezes. O padrão [a-z]+ encontra um caractere de a-z uma ou mais vezes. Use quantificador com cuidado, prestando muita atenção aos quantificadores que permitem zero similaridades. Quando usamos as chaves {} como quantificadores, devemos definir uma faixa. {3} significa exatamente 3 vezes, mas poderíamos dizer {3,}, que define no mínimo três vezes. O quantificador {3,5} encontra um padrão de 3 a 5 vezes. Há mais sobre expressões regulares que o que mostramos aqui. A arte de usá-las envolve descobrir a expressão regular correta para a situação atual. Tente diferente expressões com o programa Regex e veja se ele encontra o que você está esperando. Certifique-se de tentar diferentes quantificadores para entender realmente suas diferenças. Observe que quantificadores geralmente tentam incluir o maior número de caracteres para uma similaridade possível. |
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Arrays e Matrix (Vetores e Matrizes) |
Exercícios Resolvidos de Java - Escreva um programa Java para mover todos os zeros para o final do vetor, sem alterar a ordem dos elementos já presentes no arrayQuantidade de visualizações: 624 vezes |
Pergunta/Tarefa: Dado o seguinte vetor de inteiros: // vamos declarar e construir um vetor de 8 inteiros int valores[] = {0, 3, 0, 5, 7, 4, 0, 9}; Sua saída deverá ser parecida com: Vetor na ordem original: 0 3 0 5 7 4 0 9 Vetor com os zeros deslocados para o final: 3 5 7 4 9 0 0 0 Veja a resolução comentada deste exercício usando Java: ---------------------------------------------------------------------- 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 ---------------------------------------------------------------------- package exercicio; public class Exercicio { public static void main(String[] args) { // vamos declarar e construir um vetor de 8 inteiros int valores[] = {0, 3, 0, 5, 7, 4, 0, 9}; // vamos mostrar o vetor na ordem original System.out.println("Vetor na ordem original:\n"); for(int i = 0; i < valores.length; i++){ System.out.print(valores[i] + " "); } // vamos inicializar j como 0 para que ele aponte para // o primeiro elemento do vetor int j = 0; // agora o laço for percorre todos os elementos do vetor, // incrementanto a variável i e deixando o j em 0 for(int i = 0; i < valores.length; i++){ // encontramos um valor que não é 0 if(valores[i] != 0){ // fazemos a troca entre os elementos nos índices // i e j int temp = valores[i]; valores[i] = valores[j]; valores[j] = temp; // e avançamos o j para o elemento seguinte j++; } } // agora mostramos o resultado System.out.println("\n\nVetor com os zeros deslocados para o final:\n"); for(int i = 0; i < valores.length; i++){ System.out.print(valores[i] + " "); } System.out.println(); } } Não se esqueça: A resolução do exercício deve ser feita sem a criação de um vetor, array ou lista adicional, e os elementos diferentes de zero devem permanecer na mesma ordem que eles estavam antes. |
Java ::: Fundamentos da Linguagem ::: Estruturas de Controle |
Como usar a instrução switch do JavaQuantidade de visualizações: 64727 vezes |
Quando precisamos escolher entre múltiplos caminhos alternativos e esta escolha pode ser baseada em um valor inteiro, a instrução switch é uma boa opção. Veja seu uso:---------------------------------------------------------------------- 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 ---------------------------------------------------------------------- public class Estudos{ public static void main(String[] args){ int valor = 4; switch(valor){ case 1: System.out.println("Valor é 1"); break; case 2: System.out.println("Valor é 2"); break; case 3: System.out.println("Valor é 3"); break; default: System.out.println("Valor diferente de 1, 2 e 3"); break; } } } A variável fornecida à instrução switch deve ser do tipo byte, short, char, ou int. Ela não pode ser long, float, double, boolean ou referência a objetos. Veja o que acontece quando tentamos usar uma variável do tipo long: Estudos.java:5: possible loss of precision found : long required: int switch(valor){ ^ 1 error |
Java ::: Dicas & Truques ::: Strings e Caracteres |
Como contar as ocorrências de uma substring em uma string do Java usando o método substring() e um laço forQuantidade de visualizações: 3 vezes |
Nesta dica mostrarei como podemos usar o método substring() da classe String, combinado com o laço for, para contar as ocorrências de uma substring em uma string da linguagem Java. Note que usamos também os métodos length() e equals() para completar a tarefa. Veja o código Java completo para o exemplo: ---------------------------------------------------------------------- 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 ---------------------------------------------------------------------- package estudos; public class Estudos{ public static void main(String[] args){ // vamos criar uma string representando uma frase String frase = "Programar em Java só é melhor que programar em Java"; // a substring que vamos pesquisar String sub = "Java"; // ocorrências de "Java" // quantidade de ocorrências int cont = 0; // um laço for que vai de 0 até o tamanho da primeira string menos // o tamanho da segunda string - 1 for(int i = 0; i < (frase.length() - sub.length() + 1); i++){ String res = frase.substring(i, (i + sub.length())); // encontramos a substring mais uma vez? if(res.equals(sub)){ cont++; } } System.out.println("A frase contém " + cont + " ocorrências de " + sub); // fecha o programa System.exit(0); } } Ao executar este código Java nós teremos o seguinte resultado: A frase contém 2 ocorrências de Java |
Java ::: Topografia e Geoprocessamento ::: Passos Iniciais |
Como converter graus, minutos e segundos para graus decimais em JavaQuantidade de visualizações: 456 vezes |
Em algumas situações, principalmente em cálculos da Engenharia Civil e Topografia, nós precisamos converter graus, minutos e segundos para graus decimais. É comum chamarmos graus, minutos e segundos de DMS ou GMS, enquanto os graus decimais são chamados de UTM. Nesta dica veremos como converter 85º 42' 13.75'' para graus decimais. A fórmula que usaremos é a seguinte: \[\text{Graus decimais} = \text{Graus} + \frac{\text{Minutos}}{60} + \frac{\text{Segundos}}{3600} \] Veja agora o código Java completo que pede para o usuário informar os graus, os minutos e os segundos e mostra os graus decimais: ---------------------------------------------------------------------- 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 ---------------------------------------------------------------------- package estudos; import java.util.Scanner; public class Estudos { public static void main(String[] args) { // para ler a entrada do usuário Scanner entrada = new Scanner(System.in); // vamos pedir para o usuário informar os graus, minutos // e segundos System.out.print("Informe os graus: "); double graus = Double.parseDouble(entrada.nextLine()); System.out.print("Informe os minutos: "); double minutos = Double.parseDouble(entrada.nextLine()); System.out.print("Informe os segundos: "); double segundos = Double.parseDouble(entrada.nextLine()); // agora vamos calcular os graus decimais double grausDecimais = graus + (minutos / 60.0) + (segundos / 3600.0); // e agora mostramos o resultado System.out.println("Os graus decimais são: " + grausDecimais); } } Ao executar este código Java nós teremos o seguinte resultado: Informe os graus: 85 Informe os minutos: 42 Informe os segundos: 13.75 Os graus decimais são: 85.70381944444445 Fique atento ao sinal. Se o valor em graus, minutos e segundos possuir os caracteres "W" ou "S", então o valor em graus decimais deverá levar o sinal de negativo. |
Java ::: Dicas & Truques ::: Mouse e Teclado |
Java Swing - Como detectar um clique em um botão JButton e exibir uma mensagem JOptionPaneQuantidade de visualizações: 7 vezes |
Nesta dica mostrarei como podemos usar o método addActionListener() da linguagem Java para definir um evento de clique a um botão JButton. Quando o usuário clicar no botão nós vamos interceptar este evento e mostrar uma mensagem JOptionPane.showMessageDialog(). Veja o código completo para o exemplo: ---------------------------------------------------------------------- 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 ---------------------------------------------------------------------- import javax.swing.*; import java.awt.*; import java.awt.event.*; public class Estudos extends JFrame{ JButton btn; public Estudos() { super("Detectando um clique em um botão"); Container c = getContentPane(); FlowLayout layout = new FlowLayout(FlowLayout.LEFT); c.setLayout(layout); btn = new JButton("Clique"); btn.addActionListener( new ActionListener(){ public void actionPerformed(ActionEvent e){ JOptionPane.showMessageDialog(null, "Fui clicado!"); } } ); c.add(btn); setSize(350, 250); setVisible(true); } public static void main(String args[]){ Estudos app = new Estudos(); app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } } |
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Métodos, Procedimentos e Funções |
Exercícios Resolvidos de Java - Como escrever uma função Java que recebe dois números inteiros e retorna a soma desses dois valores como um inteiroQuantidade de visualizações: 9686 vezes |
Pergunta/Tarefa: Escreva um método estático em Java chamado somar() que recebe dois números inteiros e retorna a soma desses dois valores como um inteiro. Este método deverá ter a seguinte assinatura: public static int somar(int a, int b){ // sua implementação aqui } Sua saída deverá ser parecida com: Informe o primeiro número: 4 Informe o segundo número: 3 A soma dos dois números é: 7 Veja a resolução comentada deste exercício usando Java: ---------------------------------------------------------------------- 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 ---------------------------------------------------------------------- package estudos; import java.util.Scanner; public class Estudos { public static void main(String[] args) { // vamos fazer a leitura usando a classe Scanner Scanner entrada = new Scanner(System.in); // vamos pedir ao usuário que informe dois valores inteiros System.out.print("Informe o primeiro número: "); int n1 = Integer.parseInt(entrada.nextLine()); System.out.print("Informe o segundo número: "); int n2 = Integer.parseInt(entrada.nextLine()); // vamos efetuar uma chamada ao método somar() e obter seu retorno int resultado = somar(n1, n2); // finalmente mostramos o resultado System.out.println("A soma dos dois números é: " + resultado); } // método estático que recebe dois inteiros e retorna a soma como um número inteiro public static int somar(int a, int b){ int soma = a + b; // soma os dois números return soma; // retorna a soma para o método chamado } } |
Vamos testar seus conhecimentos em Ética e Legislação Profissional |
Ética Empresarial e Profissional: Noções Gerais A ética investiga a forma do comportamento humano e da moral e busca explicá-los. É nesse contexto que se concentra o verdadeiro valor da ética. Portanto, a ética fornece a compreensão racional do comportamento humano, o qual será, posteriormente, o elemento formador da consciência. Assinale a alternativa que explica a função da consciência. A) A consciência nos leva a buscar o que é realmente bom, correto e justo, mantendo as mesmas condições que determinam limites e capacidades. B) A consciência não nos leva a buscar necessariamente o que é correto e justo. C) A consciência não é influenciada pela ética em nenhum aspecto ou momento. D) A consciência nos leva a buscar o que é realmente bom, correto e justo, visando a identificar e a estabelecer os novos parâmetros que nortearão os limites e as capacidades. E) A consciência nos leva a buscar o que é realmente bom, correto e justo, condicionando-se aos interesses particulares. Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em Python |
Analise o seguinte código Pythonletras = ['ab', 'cd'] for i in range(len(letras)): letras[i].upper() print(letras) Qual é o resultado de sua execução? A) ['AB', 'CD'] B) ['ab', 'cd'] C) ['Ab', 'Cd'] D) ['aB', 'cD'] 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 JavaScript |
A linguagem JavaScript diferencia letras maiúsculas de letras minúsculas (case-sensitive)? A) Sim B) Não Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em |
Vigas a flexão simples: seções retangulares Quando uma viga é simplesmente armada, significa que o aço está sendo utilizado para resistir às solicitações das regiões da seção que estão sendo submetidas à tração, e o concreto está sendo utilizado para resistir às solicitações de compressão. Considere que uma viga contínua V (15x40) tem uma solicitação de momento fletor de 45,20kN.m. O concreto utilizado nessa viga tem resistência de 25MPa e a agressividade ambiental do local é classe II (considere que é uma viga pouco solicitada). Das alternativas a seguir, assinale aquela que apresenta a área de aço da armadura longitudinal dessa viga. A) 2,93cm2. B) 3,26cm2. C) 4,11cm2. D) 4,57cm2. E) 4,75cm2. Verificar Resposta Estudar Cards Todas as Questões |
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 |
JavaScript - Como remover elementos duplicados de um array em JavaScript usando um Set e o método Array.from() C++ - Como inicializar os valores dos elementos de um vetor C++ usando valores randômicos - Revisado |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
1º lugar: Java |