Questões - Operadores
01 - Escreva um programa que declare duas variáveis inteiras, a com o valor 15 e b com o valor 7, e imprima a soma delas.
Resposta
fn main() {
let a: u8 = 15;
let b: u8 = 7;
println!("{:?}", a + b);
}02 - Crie um código que subtraia o valor 3 de uma variável chamada total que é inicialmente igual a 10, e exiba o resultado.
Resposta
fn main() {
let total = 10;
let sub = total - 3;
println!("{:?}", sub);
let mut total = 10;
total -= 3;
println!("{:?}", total);
}03 - Desenvolva um programa que multiplique duas variáveis, x igual a 6 e y igual a 8, e mostre o produto.
Resposta
fn main() {
let x: u8 = 6;
let y: u8 = 8;
let result: u8 = x * y;
println!("{:?}", result);
}04 - Implemente um código que divida o número 20 por 5 e imprima o quociente.
Resposta
fn main() {
let result = 20 / 5;
println!("{}", result);
}05 - Escreva um programa que calcule o resto da divisão de 23 por 4 e imprima o resultado.
Resposta
fn main() {
let mut resto: u8 = 23;
resto %= 4;
println!("{:?}", resto);
}06 - Declare duas variáveis num1 = 12 e num2 = 5 e imprima o resultado da soma delas diretamente dentro da macro println!.
Resposta
fn main() {
let num1: u8 = 12;
let num2: u8 = 5;
println!("{:?}", num1 + num2);
}07 - Crie uma variável imutável chamada valor que seja a soma de 9 e 2, e imprima seu valor.
Resposta
fn main() {
let valor: u8 = 9 + 2;
println!("{:?}", valor);
}08 - Declare uma variável mutável chamada contador com um valor inicial de 5. Incremente-a em 3 usando o operador de atribuição de adição (+=) e imprima o novo valor.
Resposta
fn main() {
let mut contador: u8 = 5;
contador += 3;
println!("{:?}", contador);
}09 - Crie uma variável mutável score inicializada com 20. Decremente-a em 5 usando o operador de atribuição de subtração (-=) e exiba o valor final.
Resposta
fn main() {
let mut score: u8 = 20;
score -= 5;
println!("{:?}", score);
}10 - Declare uma variável mutável numero com o valor 2. Multiplique-a por 4 usando o operador de atribuição de multiplicação (*=) e imprima o resultado.
Resposta
fn main() {
let mut numero: u8 = 2;
numero *= 4;
println!("{:?}", numero);
}11 - Inicialize uma variável mutável size com 30. Divida-a por 6 usando o operador de atribuição de divisão (/=) e mostre o valor resultante.
Resposta
fn main() {
let mut size: u8 = 30;
size /= 6;
println!("{:?}", size);
}12 - Declare uma variável mutável numero com o valor 17. Calcule o resto da divisão por 5 usando o operador de atribuição de resto (%=) e imprima o valor.
Resposta
fn main() {
let mut numero: u8 = 17;
numero %= 5;
println!("{:?}", numero);
}13 - Declare duas variáveis do tipo &str, part1 com Hello, e part2 com Rust!. Concatene-as e imprima o resultado.
Resposta
fn main() {
let part1: &str = "Hello, ";
let part2: &str = "Rust!";
println!("{}{}", part1, part2);
}14 - Crie duas variáveis do tipo string, s1 = “Linguagem “ e s2 = “Rust.”. Concatene-as e imprima a string resultante.
Resposta
fn main() {
let s1: String = String::from("Linguagem ");
let s2: String = String::from("Rust.");
println!("{:?}", s1 + &s2);
}15 - Declare uma variável do tipo &str chamada numero com o valor “Numero: “. Crie uma variável do tipo string chamada numero_str com o valor “42”. Concatene-as e imprima o resultado.
Resposta
fn main() {
let numero: &str = "Numero: ";
let numero_str: String = String::from("42");
println!("{:?}", numero.to_owned() + &numero_str);
}16 - Declare uma tupla com dois i32. Inicialize-a com os valores (5, -2). Imprima a multiplicação desses dois valores.
Resposta
fn main() {
let tup: (i32, i32) = (5, -2);
println!("{:?}", tup.0 * tup.1);
}17 - Crie uma tupla aninhada: ((1, 2), (3, 4)). Some o primeiro elemento da primeira tupla ao segundo elemento da segunda tupla e imprima o resultado.
Resposta
fn main() {
let tup: ((u8, u8), (u8, u8)) = ((1, 2), (3, 4));
println!("{:?}", tup.0 .0 + tup.1 .1);
}18 - Declare duas tuplas, t1 com (2, 5) e t2 com (8, 1). Some todos os elementos das duas tuplas e imprima o total.
Resposta
fn main() {
let t1: (u8, u8) = (2, 5);
let t2: (u8, u8) = (8, 1);
println!("{:?}", t1.0 + t1.1 + t2.0 + t2.1);
}19 - Declare um array = [i32; 5] com os valores [1, 3, 5, 7, 9]. Imprima a soma do primeiro e último elementos.
Resposta
fn main() {
let arr: [i32; 5] = [1, 3, 5, 7, 9];
println!("{:?} + {:?} = {:?}", arr[0], arr[4], arr[0] + arr[4]);
}20 - Crie um array de [u16; 3]. Inicialize-o com os valores [10, 20, 30]. Imprima o produto de todos os elementos.
Resposta
fn main() {
let arr: [u16; 3];
arr = [10, 20, 30];
println!("{:?}", arr[0] * arr[1] * arr[2]);
}21 - Declare um array multidimensional 2x2 com inteiros. Multiplique todos os elementos e imprima o resultado.
Resposta
fn main() {
let arr: [[i8; 2]; 2];
arr = [[2, 2], [4, 4]];
println!("{:?}", arr[0][0] * arr[0][1] * arr[1][0] * arr[1][1]);
}22 - Declare uma variável x com valor 1. Crie um bloco interno onde você declare uma variável y com valor 2. Dentro do bloco, imprima a soma de x e y. Fora do bloco, tente imprimir y (o que acontecerá?).
Resposta
fn main() {
let x: u8 = 1;
{
let y: u8 = 2;
println!("{:?}", x + y);
}
println!("{:?}", x);
// println!("{:?}", y); // Erro: `y` fora do escopo
}23 - Declare uma variável level1 com valor 10. Abra um novo bloco e declare uma variável level2 com valor 20. Dentro deste bloco, crie outro bloco e declare level3 com valor 30. Imprima a soma de level1, level2 e level3 dentro do bloco mais interno.
Resposta
fn main() {
let level1: u8 = 10;
{
let level2: u8 = 20;
{
let level3: u8 = 30;
println!("{:?}", level1 + level2 + level3);
}
println!("{:?}", level2);
}
println!("{:?}", level1);
}24 - Declare uma variável principal com valor 100. Crie um bloco onde você declare uma variável com o mesmo nome e atribua o valor 50.0. Imprima o valor da variável dentro do bloco e fora do bloco.
Resposta
fn main() {
let principal: u8 = 100;
println!("{:?}", principal);
{
let principal: f32 = 50.;
println!("{:?}", principal);
}
println!("{:?}", principal);
}25 - Usando os valores de um array var = [2, 3], escreva um código que calcule e imprima o resultado de (var[0] + var[1]) * var[1].
Resposta
fn main() {
let var: [u8; 2] = [2, 3];
println!("{:?}", (var[0] + var[1]) * var[1]);
}26 - Ainda com a variável var = [2, 3], calcule e imprima var[0] * var[1] / var[1] % var[1].
Resposta
fn main() {
let var: [u8; 2] = [2, 3];
println!("{:?}", var[0] * var[1] / var[1] % var[1]);
}27 - Calcule e imprima var[0] + var[1] − var[0] + var[0] * var[0]. (Usando var com [2, 3]).
Resposta
fn main() {
let var: [u8; 2] = [2, 3];
println!("{:?}", var[0] + var[1] - var[0] + var[0] * var[0]);
}28 - Calcule e imprima ((var[0] + var[1]) − (var[0] + var[0]) * var[0]). (Usando var com [2, 3]).
Resposta
fn main() {
let var: [i8; 2] = [2, 3];
println!("{:?}", (var[0] + var[1]) - (var[0] + var[0]) * var[0]);
}29 - Declare duas variáveis inteiras, num1 com valor 10 e num2 com valor 10. Escreva um código que imprima se num1 é igual a num2 (==).
Resposta
fn main() {
let num1: i8 = 10;
let num2: i8 = 10;
println!("Num1 = Num2? {:?} ", num1 == num2);
}30 - Declare duas variáveis de ponto flutuante, f1 com 3.14 e f2 com 2.71. Escreva um código que imprima se f1 é diferente de f2 (!=).
Resposta
fn main() {
let f1: f32 = 3.14;
let f2: f32 = 2.71;
println!("f1 != f2? {}", f1 != f2);
}31 - Declare duas variáveis inteiras, idade_a com 25 e idade_b com 30. Escreva um código que imprima se idade_a é maior que idade_b (>).
Resposta
fn main() {
let idade_a: u8 = 25;
let idade_b: u8 = 30;
println!("Idade A > Idade B? {}", idade_a > idade_b);
}32 - Declare duas variáveis inteiras, point1 com 5 e point2 com 8. Escreva um código que imprima se point1 é menor que point2 (<).
Resposta
fn main() {
let point1: u8 = 5;
let point2: u8 = 8;
println!("Point1 < Point2? {}", point1 < point2);
}33 - Declare duas variáveis inteiras, nota_a com 7 e nota_b com 7. Escreva um código que imprima se nota_a é maior ou igual a nota_b (>=).
Resposta
fn main() {
let nota_a: u8 = 7;
let nota_b: u8 = 7;
println!("Nota A >= Nota B? {}", nota_a >= nota_b);
}34 - Declare duas variáveis float, altura_a com 1.70 e altura_b com 1.65. Escreva um código que imprima se altura_a é menor ou igual a altura_b (<=).
Resposta
fn main() {
let altura_a: f32 = 1.70;
let altura_b: f32 = 1.65;
println!("Altura A <= Altura B? {}", altura_a <= altura_b);
}35 - Declare uma variável temp_a com 22.5 e temp_b com 20.0. Verifique se temp_a é maior que temp_b (>) e imprima.
Resposta
fn main() {
let temp_a: f32 = 22.5;
let temp_b: f32 = 20.;
println!("Temperatura A > Temperatura B? {}", temp_a > temp_b);
}36 - Declare uma variável count_a com 100 e count_b com 99. Verifique se count_a é menor que count_b (<) e imprima.
Resposta
fn main() {
let count_a: u8 = 100;
let count_b: u8 = 99;
println!("Count A < Count B? {}", count_a < count_b);
}37 - Declare duas variáveis u8, val_a com 8 e val_b com 3. Calcule a soma, subtraia 1 do resultado, e imprima.
Resposta
fn main() {
let val_a: u8 = 8;
let val_b: u8 = 3;
println!("{:?}", (val_a + val_b) - 1);
}38 - Declare um array [i32; 3] = [2, 4, 6]. Divida cada elemento por 2 (usando atribuição de divisão se aplicável) e imprima o array resultante.
Resposta
fn main() {
let mut arr: [i32; 3] = [2, 4, 6];
arr[0] /= 2;
arr[1] /= 2;
arr[2] /= 2;
println!("{:#?}", arr);
}39 - Declare uma tupla (f64, f64) = (2.5, 3.5). Some os elementos e imprima o resultado formatado com duas casas decimais.
Resposta
fn main() {
let tup: (f64, f64) = (2.5, 3.5);
let result: f64 = tup.0 + tup.1;
println!("{:.2}", result);
}40 - Declare uma variável mensagem do tipo &str com “Start”. Anexe a ela a String “ -> End“. Imprima o valor final de mensagem.
Resposta
fn main() {
//&str
let mensagem: &str = "Start";
println!("{}", mensagem.to_owned() + " -> End");
}fn main() {
// string
let mut mensagem: String = String::from("Start");
mensagem += " -> End";
println!("{}", mensagem);
}