[EN]

Rust Learning Projects

Welcome to my collection of Rust learning projects! This repository is dedicated to exploring, learning, and practicing the common features of the Rust programming language through a series of small, focused projects. Each project tackles different aspects of Rust, making this compilation a comprehensive guide for anyone looking to deepen their understanding of the language.

Introduction

Rust is a modern systems programming language that offers memory safety, concurrency, and high performance. It's designed to encourage writing clean, efficient code. This repository represents my journey through Rust, showcasing projects that range from basic syntax and concepts to more complex language features.

Projects Overview

Here's a snapshot of what each project focuses on:

• caracteres_unicos: Explore how to identify unique characters within strings.
• fatorial: Implement the mathematical factorial function to understand Rust's handling of recursion and loops.
• guessing_game: A classic beginner project to get hands-on experience with Rust's input/output, randomness, and basic control flows.
• hello_cargo: Get to know Cargo, Rust's package manager and build system, through a simple "Hello, World!" application.
• hello_world: The initial step into Rust programming, printing "Hello, World!" to the console.
• int_converter: Delve into type conversion in Rust by creating a utility that converts between different integer types.
• max_number: Learn how to process a collection of numbers to find the maximum value, showcasing Rust's handling of iterators and comparisons.
• media_notas: Calculate the average of a series of grades, introducing Rust's approach to numerical operations and user input.
• mmc: Discover the method to calculate the Least Common Multiple (LCM) of two numbers, enhancing understanding of algorithms in Rust.
• num_primo: Implement a prime number checker to practice Rust's control flow constructs and its efficient number processing capabilities.
• palindromo_num: Create a program that checks if a number is a palindrome, focusing on string and numerical manipulations in Rust.
• permuta_string: Explore string permutations to understand Rust's memory safety features and its powerful collection manipulation capabilities.
• playing: A sandbox project for experimenting with various Rust concepts and the standard library without a specific focus.
• reverse_string: Develop a function to reverse strings, showcasing Rust's handling of Unicode and string manipulation.
• soma_sequencia: Implement a sequence sum calculator to get familiar with loops and iterators in Rust.
• tabuada: Generate multiplication tables, providing a practical example of nested loops and basic arithmetic operations.
• variables: Understand Rust's variable declarations, mutability, and basic data types through simple examples.

Getting Started

To dive into these projects, ensure you have Rust and Cargo installed on your machine. You can install both by following the official guide at https://www.rust-lang.org/tools/install.

To run any project, clone this repository, navigate into the project's directory, and use Cargo to build and run the project:

git clone https://github.com/dansal0807/rust-practice.git
cd rust-practice/project-directory
cargo run

Learning Resources

Here are some resources that I used:

• The Rust Programming Language (The Book): The Rust Programming Language

  This is the official source for learning Rust, covering everything from basics to advanced topics.

• Rust by Example: Rust by Example

  A collection of runnable examples that illustrate various Rust concepts and standard libraries, making it a great hands-on way to learn.

• Rustlings: Rustlings

  This GitHub repository offers small exercises to help you get used to reading and writing Rust code, perfect for beginners.

Contribution

Feel free to contribute to any of the projects by submitting pull requests or opening issues for any bugs or enhancements you identify. Your contributions are highly appreciated!

---

[PT-BR]

Projetos de Prática de Rust

Este repositório é dedicado a explorar, aprender e praticar os recursos comuns da linguagem de programação Rust por meio de uma série de projetos pequenos e focados. Cada projeto aborda diferentes aspectos do Rust, tornando esta compilação um guia abrangente para qualquer pessoa que deseje aprofundar seu entendimento da linguagem.

Introdução

Rust é uma linguagem de programação de sistemas moderna que oferece segurança de memória, concorrência e alto desempenho. É projetada para incentivar a escrita de código limpo e eficiente. Este repositório representa minha jornada através do Rust, exibindo projetos que variam desde a sintaxe básica e conceitos até características mais complexas da linguagem.

Visão Geral dos Projetos

Aqui está um resumo do que cada projeto foca:

• caracteres_unicos: Explore como identificar caracteres únicos dentro de strings.
• fatorial: Implemente a função matemática de fatorial para entender o tratamento do Rust com recursão e loops.
• guessing_game: Um projeto clássico para iniciantes para obter experiência prática com entrada/saída do Rust, aleatoriedade e fluxos de controle básicos.
• hello_cargo: Conheça o Cargo, o gerenciador de pacotes e sistema de construção do Rust, por meio de uma simples aplicação "Hello, World!".
• hello_world: O primeiro passo na programação Rust, imprimindo "Hello, World!" no console.
• int_converter: Aprofunde-se na conversão de tipos em Rust criando uma utilidade que converte entre diferentes tipos de inteiros.
• max_number: Aprenda a processar uma coleção de números para encontrar o valor máximo, mostrando o tratamento do Rust com iteradores e comparações.
• media_notas: Calcule a média de uma série de notas, introduzindo a abordagem do Rust para operações numéricas e entrada do usuário.
• mmc: Descubra o método para calcular o Mínimo Múltiplo Comum (MMC) de dois números, melhorando o entendimento de algoritmos em Rust.
• num_primo: Implemente um verificador de números primos para praticar as construções de controle de fluxo do Rust e suas capacidades eficientes de processamento de números.
• palindromo_num: Crie um programa que verifica se um número é um palíndromo, focando em manipulações de string e numéricas em Rust.
• permuta_string: Explore permutações de string para entender as características de segurança de memória do Rust e suas poderosas capacidades de manipulação de coleções.
• playing: Um projeto de sandbox para experimentar com vários conceitos do Rust e a biblioteca padrão sem um foco específico.
• reverse_string: Desenvolva uma função para reverter strings, mostrando o tratamento do Rust com Unicode e manipulação de strings.
• soma_sequencia: Implemente um calculador de soma de sequência para se familiarizar com loops e iteradores em Rust.
• tabuada: Gere tabelas de multiplicação, fornecendo um exemplo prático de loops aninhados e operações aritméticas básicas.
• variables: Entenda as declarações de variáveis do Rust, mutabilidade e tipos de dados básicos por meio de exemplos simples.

Começando

Para mergulhar nesses projetos, certifique-se de ter o Rust e o Cargo instalados em sua máquina. Você pode instalar ambos seguindo o guia oficial em https://www.rust-lang.org/tools/install.

Para executar qualquer projeto, clone este repositório, navegue até o diretório do projeto e use o Cargo para construir e executar o projeto:

git clone https://github.com/dansal0807/rust-practice.git
cd rust-practice/diretorio-do-projeto
cargo run