CodeUtility
Tornando o seu trabalho de dev mais simples!

Online Rust Compiler

Write, compile, run, and debug Rust code online in a full-featured browser IDE. Work with multiple files, save your workspace, and share or collaborate in real time.

Bibliotecas pré-instaladas
🚀 252,702 execuções totais (135 este mês)
Incorporar
Saída

Pratique Rust com desafios de código

Resolva problemas práticos direto neste editor: rode os testes de exemplo, envie sua solução e receba uma revisão de código por IA.

Todos os desafios de Rust
Fácil

Rectangle Perimeter

Compute the perimeter of a rectangle from its sides.

Você vai aprender AritméticaValores de retorno
BeginnerLearning-pathVariables
Python C++ C# Java JavaScript Go Rust Kotlin Swift
12 resolvidos
Ver soluções (12)
Fácil

Distance Between Points

Compute the straight-line distance between two points.

Você vai aprender Teorema de PitágorasRaízes quadradas
BeginnerFunctionsLearning-pathmath
Python C++ C# Swift Java JavaScript Go Rust Kotlin
7 resolvidos
Ver soluções (7)
Fácil

Dias em um Mês

Retorne quantos dias tem um mês, incluindo anos bissextos.

Você vai aprender Regras do calendárioFunções auxiliares
BeginnerConditionsFunctionsLearning-path
Python C++ C# Java JavaScript Go Rust Kotlin Swift
6 resolvidos
Ver soluções (6)
Fácil

Average of Three

Average three whole numbers.

Você vai aprender AritméticaDivisão
BeginnerLearning-pathVariables
Python C++ C# Java JavaScript Go Rust Kotlin Swift
6 resolvidos
Ver soluções (6)
Fácil

Produto escalar de dois vetores

Multiplique dois vetores elemento a elemento e some os resultados, a operação central de todo neurônio.

Você vai aprender VetoresProduto escalar
Redes neuraisaiaprendizado de máquina
Python C++ C# Java JavaScript Go Rust Kotlin Swift
4 resolvidos
Ver soluções (4)
Fácil

Largest of Three

Pick the largest of three numbers without a built-in max.

Você vai aprender ComparaçõesCombinar condições
BeginnerConditionsLearning-path
Python C++ C# Java JavaScript Go Rust Kotlin Swift
4 resolvidos
Ver soluções (4)
Fácil

Verificação de Número Primo

Decida se um número é primo.

Você vai aprender DivisibilidadeOtimizar laços
BeginnerLoopsNumbersStudent-beginner
Kotlin Swift Python C++ C# Java JavaScript Go Rust
3 resolvidos
Ver soluções (3)
Fácil

Number Triangle

Build a triangle of increasing numbers.

Você vai aprender Linhas crescentesContador entre linhas
BeginnerLearning-pathNested-loopsPatterns
Python C++ C# Java JavaScript Go Rust Kotlin Swift
3 resolvidos
Ver soluções (3)
Fácil

Número de Armstrong

Verifique se um número é igual à soma de seus dígitos elevados à quantidade de dígitos.

Você vai aprender Extrair dígitosPotências
BeginnerNumbersStudent-beginner
JavaScript Python C++ C# Java Go Rust Kotlin Swift
3 resolvidos
Ver soluções (3)
Fácil

Row Sums

Add up every row of a grid.

Você vai aprender Listas 2DLaços aninhados
BeginnerGridsLearning-path
Python C++ C# Java JavaScript Go Rust Kotlin Swift
3 resolvidos
Ver soluções (3)
Fácil

Min and Max Together

Find the smallest and largest value in one pass.

Você vai aprender Uma única passadaVários valores de retorno
ArraysBeginnerFunctionsLearning-path
Python C++ C# Java JavaScript Go Rust Kotlin Swift
3 resolvidos
Ver soluções (3)
Fácil

Count Pairs With a Sum

Count pairs of positions whose values add up to a target.

Você vai aprender Pares de índicesEvitar contagem dupla
ArraysBeginnerLearning-pathNested-loops
Python C++ C# Java JavaScript Go Rust Kotlin Swift
3 resolvidos
Ver soluções (3)

🦀 Sobre este executor online de Rust

O CodeUtility Rust Executor permite escrever e executar código Rust diretamente no seu navegador - sem instalação, configuração de toolchain ou ambiente local. Ele é alimentado por um sandbox seguro que oferece suporte às versões reais do compilador Rust 1.70, 1.72, 1.73 e 1.74.

Esta ferramenta compila e executa seus programas Rust na nuvem usando um compilador rustc autêntico, garantindo resultados precisos e consistentes. Você pode experimentar com variáveis, ownership, borrowing, pattern matching, traits, genéricos e outros recursos modernos do Rust com facilidade.

É ideal para aprender os conceitos fundamentais de Rust - especialmente segurança de memória, tratamento de erros e concorrência - sem precisar instalar o Cargo ou qualquer setup local. Tudo roda diretamente no seu navegador em segundos.

Mais do que um executor de código

Use no mesmo executor um editor de vários arquivos, um terminal de execução isolado, bibliotecas específicas do ambiente, espaços de trabalho persistentes, compartilhamento e colaboração em tempo real.

Como usar este executor?

Escolha um ambiente de execução, abra ou crie um arquivo, escreva o código e selecione Executar. A saída aparece no terminal; usuários conectados podem manter arquivos em um espaço de trabalho, instalar bibliotecas e colaborar por meio de compartilhamentos.

  1. Selecione uma versão e edite o arquivo atual ou abra outro arquivo do espaço de trabalho.
  2. Execute o código, forneça dados no terminal quando solicitado e consulte o histórico de execuções salvo.
  3. Use bibliotecas, ferramentas do espaço de trabalho, compartilhamento e chat quando a tarefa exigir mais de um trecho de código.

💡 Noções básicas de Rust e exemplos que você pode testar acima

1. Declarando variáveis e constantes

Use let para declarar variáveis. Use const para constantes e mut para variáveis mutáveis.

let x = 10;
let pi: f64 = 3.14;
let name = "Alice";
let is_active = true;

const MAX_USERS: u32 = 100;

2. Condicionais (if / match)

Rust usa if para condições e match para correspondência de padrões.

let x = 2;
if x == 1 {
    println!("One");
} else if x == 2 {
    println!("Two");
} else {
    println!("Other");
}

match x {
    1 => println!("One"),
    2 => println!("Two"),
    _ => println!("Other"),
}

3. Loops

Rust oferece suporte a for, while e loop infinito.

for i in 0..3 {
    println!("{}", i);
}

let mut n = 3;
while n > 0 {
    println!("{}", n);
    n -= 1;
}

4. Arrays

Arrays de tamanho fixo em Rust usam colchetes. Use slices para visualizações.

let nums = [10, 20, 30];
println!("{}", nums[1]);

5. Vetores (arrays dinâmicos)

Vec é usado para arrays dinâmicos.

let mut fruits = vec!["apple", "banana"];
fruits.push("cherry");
fruits.pop();

for fruit in &fruits {
    println!("{}", fruit);
}

6. Entrada/Saída no console

Use println! para saída e std::io para entrada.

use std::io;

let mut name = String::new();
println!("Enter your name:");
io::stdin().read_line(&mut name).unwrap();
println!("Hello, {}", name.trim());

7. Funções

Funções usam fn e podem retornar valores usando ->.

fn greet(name: &str) -> String {
    format!("Hello, {}", name)
}

println!("{}", greet("Alice"));

8. HashMaps

Use std::collections::HashMap para dados chave-valor.

use std::collections::HashMap;

let mut person = HashMap::new();
person.insert("name", "Bob");
println!("{}", person["name"])

9. Tratamento de erros

Rust lida com erros usando Result e match ou unwrap().

fn fail() -> Result<(), String> {
    Err("Something went wrong".to_string())
}

match fail() {
    Ok(_) => println!("Success"),
    Err(e) => println!("{}", e),
}

10. I/O de arquivos

Use std::fs para ler e escrever arquivos.

use std::fs;

fs::write("file.txt", "Hello File").unwrap();
let content = fs::read_to_string("file.txt").unwrap();
println!("{}", content);

11. Manipulação de strings

Strings em Rust são alocadas no heap e oferecem muitos métodos.

let mut text = String::from(" Hello Rust ");
println!("{}", text.trim());
println!("{}", text.to_uppercase());
text = text.replace("Hello", "Hi");
println!("{}", text);

12. Structs e métodos

Rust usa struct para tipos de dados e impl para métodos.

struct Person {
    name: String,
}

impl Person {
    fn greet(&self) -> String {
        format!("Hi, I'm {}", self.name)
    }
}

let p = Person { name: "Alice".to_string() };
println!("{}", p.greet());

13. Referências e empréstimo

Rust usa & para emprestar valores e &mut para referências mutáveis.

fn update(x: &mut i32) {
    *x += 1;
}

let mut value = 10;
update(&mut value);
println!("{}", value);