学习Rust的第三天：猜谜游戏

news2025/1/16 6:38:13

Welcome to the third day of learning rust, I am referring to the book “The Rust Programming Language” by Steve Klabnik. Today we build a guessing game in rust.
欢迎来到学习Rust的第三天，基于Steve Klabnik的《The Rust Programming Language》一书。今天我们在rust中建立一个猜谜游戏。

Introduction 介绍

We will build a game that will pick a random number between 1 to 100 and the user has to guess the number on a correct guess the user wins.
我们将构建一个游戏，它将选择1到100之间的随机数字，用户必须猜测正确的猜测用户获胜的数字。

Algorithm 算法

This is what the pseudo code would look like
这就是伪代码的样子

secret_number = (Generate a random number)
loop {
	Write “Please input your guess”
	Read guess
	Write "Your guess : ${guess}"
	
	if(guess > secret_number){
		Write "Too high!"
	}else if(guess < secret_number){
		Write "Too low!"
	}else if(guess==number){
		Write "You win"
		break
	}
}

Step 1 : Set up a new project
步骤1：创建一个新项目

Use the cargo new command to set up a project
使用 cargo new 命令设置项目

$ cargo new guessing_game
$ cd guessing_game

Step 2 : Declaring variables and reading user input
步骤2：声明变量并阅读用户输入

Filename : main.rs Film：main.rs

use std::io;

fn main() {
    println!("Guess the number");
    println!("Please input your guess");

    let mut guess = String::new();

    io::stdin().read_line(&mut guess).expect("Failed to read line");
    println!("Your guess: {}", guess);
}

Let’s break the code down line by line :
让我们逐行分解代码：

  • use std::io; This line brings the std::io (standard input/output) library into scope. The std::io library provides a number of useful features for handling input/output.
    use std::io; 此行将 std::io （标准输入/输出）库带入范围。 std::io 库提供了许多用于处理输入/输出的有用特性。
  • fn main(){...} This is the main function where the program execution begins.
    fn main(){...} 这是程序开始执行的main函数。
  • println!("Guess the number"); println! is a macro that prints the text to the console.
    println!("Guess the number"); println! 是一个宏，它将文本打印到控制台。
  • println!("Please input your guess"); This line prompts the user to enter their guess.
    println!("Please input your guess"); 这一行提示用户输入他们的猜测。
  • let mut guess = String::new(); This line declares a mutable variable guess and initializes it to an empty string. *mut means the variable is mutable*, i.e., its value can be changed. String::new() creates a new, empty string.
    let mut guess = String::new(); 这一行声明了一个可变变量 guess ，并将其转换为空字符串。 *mut 表示变量是可变的 *，即，其值可以改变。 String::new() 创建一个新的空字符串。
  • io::stdin().read_line(&mut guess).expect("Failed to read line"); This line reads the user input from the standard input (keyboard). The entered input is put into the guess string. If this process fails, the program will stop execution and display the message "Failed to read line".
    io::stdin().read_line(&mut guess).expect("Failed to read line"); 这一行从标准输入（键盘）读取用户输入。输入的输入被放入 guess 字符串中。如果此过程失败，程序将停止执行，并显示消息“读取行失败”。
  • println!("Your guess : {guess}"); This line prints out the string "Your guess: ", followed by whatever the user inputted.
    println!("Your guess : {guess}"); 这一行打印出字符串“Your guess：“，后跟用户输入的任何内容。

Step 3 : Generating a random number
步骤3：生成随机数

The number should be different each time for replayability. Rust’s standard library doesn’t include random number functionality, but the Rust team provides a rand crate for this purpose.
为了可重玩性，每次的数字应该不同。Rust的标准库不包含随机数功能，但Rust团队为此提供了一个 rand crate。

A Rust crate is like a neatly packaged box of code that you can easily use and share with others in the Rust programming language.
Rust crate就像一个整齐打包的代码盒，您可以轻松使用Rust编程语言并与其他人共享。

To use the rand crate :
使用 rand crate：

Filename: Cargo.toml Filtrate：Cargo.toml

[package]
name = "guessing_game"
version = "0.1.0"
edition = "2021"

[dependencies]
rand = "0.8.5"  #append this line

Understanding the Cargo.toml file :
了解 Cargo.toml 文件：

  1. [package] [包]
  • name = "guessing_game": The name of the Rust package (or crate) is set to "guessing_game".
    name = "guessing_game" ：Rust包（或crate）的名称设置为“guessing_game”。
  • version = "0.1.0": The version of the crate is specified as "0.1.0".
    version = "0.1.0" ：机箱的版本指定为“0.1.0”。
  • edition = "2021": Specifies the Rust edition to use (in this case, the 2021 edition).
    edition = "2021" ：指定要使用的Rust版本（在本例中为2021版）。

2. [dependencies] 2. [依赖关系]

  • rand = "0.8.5": Adds a dependency on the "rand" crate with version "0.8.5". This means the "guessing_game" crate relies on the functionality provided by the "rand" crate, and version 0.8.5 specifically.
    rand = "0.8.5" ：在版本为“0.8.5”的“兰德”crate上添加依赖项。这意味着“guessing_game”crate依赖于“兰德”crate提供的功能，特别是0.8.5版本。

In simpler terms, this configuration file (Cargo.toml) is like a recipe for your Rust project, specifying its name, version, Rust edition, and any external dependencies it needs (in this case, the "rand" crate).
简单地说，这个配置文件（ Cargo.toml ）就像是Rust项目的配方，指定了它的名称、版本、Rust版本以及它需要的任何外部依赖（在本例中是“兰德”crate）。

After this without changing any code run cargo build , Why do we do that?
在此之后，不改变任何代码运行 cargo build ，为什么我们这样做？

  • Fetch Dependencies: cargo build fetches and updates the project's dependencies specified in Cargo.toml.
    获取依赖项： cargo build 获取并更新 Cargo.toml 中指定的项目依赖项。
  • Dependency Resolution: It resolves and ensures the correct versions of dependencies are installed.
    依赖项解析：它解析并确保安装了正确版本的依赖项。
  • Build Process: Compiles Rust code and dependencies into executable artifacts or libraries.
    构建过程：将Rust代码和依赖项编译为可执行工件或库。
  • Check for Errors: Identifies and reports compilation errors, ensuring code consistency.
    检查错误：检查并报告编译错误，确保代码一致性。
  • Update lock file: Updates the Cargo.lock file to record the exact dependency versions for reproducibility.
    更新锁定文件：更新 Cargo.lock 文件以记录精确的依赖性版本，以实现再现性。

Now let’s talk code 现在我们来谈谈代码

use std::io;
use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);
    println!("Secret number: {}", secret_number);

    println!("Please input your guess");

    let mut guess = String::new();

    io::stdin().read_line(&mut guess).expect("Failed to read line");
    println!("Your guess: {}", guess);
}

Running the program : 运行程序：

$ cargo run
Guess the number!
Secret number : 69
Please input your guess
32
Your guess : 32

Let’s see what we did here :
让我们看看我们在这里做了什么：

  • use rand::Rng; : This line is an import statement that brings the Rng trait into scope, allowing you to use its methods.
    use rand::Rng; ：这一行是一个import语句，它将 Rng trait带入作用域，允许你使用它的方法。
  • rand::thread_rng(): This part initializes a random number generator specific to the current thread. The rand::thread_rng() function returns a type that implements the Rng trait.
    rand::thread_rng() ：这部分提供了一个特定于当前线程的随机数生成器。 rand::thread_rng() 函数返回一个实现了 Rng trait的类型。
  • .gen_range(1..=100): Using the random number generator (Rng trait), this code calls the gen_range method to generate a random number within a specified range. The range is defined as 1..=100, meaning the generated number should be between 1 and 100 (inclusive).
    .gen_range(1..=100) ：使用随机数生成器（ Rng trait），这段代码调用 gen_range 方法来生成指定范围内的随机数。范围被定义为 1..=100 ，这意味着生成的数字应该在1和100之间（包括1和100）。

Step 4 : Comparing the guess to the user input
步骤4：将猜测与用户输入进行比较

Now that we have the input, the program compares the user’s guess to the secret number to determine if they guessed correctly. If the guess matches the secret number, the user is successful; otherwise, the program evaluates whether the guess is too high or too low.
现在我们有了输入，程序将用户的猜测与秘密数字进行比较，以确定他们是否猜对了。如果猜测与秘密数字匹配，则用户成功;否则，程序评估猜测是否过高或过低。

Let’s take a look at the code and then break it down :
让我们看看代码，然后分解它：

use std::io;
use std::cmp::Ordering;
use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);
    println!("Secret number: {}", secret_number);

    println!("Please input your guess");

    let mut guess = String::new();

    io::stdin().read_line(&mut guess).expect("Failed to read line");

    let guess: u32 = guess.trim().parse().expect("Please type a number!");
    println!("Your guess: {}", guess);

    match guess.cmp(&secret_number) {
        Ordering::Less => println!("Too small!"),
        Ordering::Greater => println!("Too big!"),
        Ordering::Equal => println!("You win!"),
    }
}

Running the program : 运行程序：

$ cargo run
Guess the number!
Secret number : 48
Please input your guess
98
Your guess : 98
Too big!

Explanation : 说明：

  • let guess: u32 = guess.trim().parse().expect("Please type a number!");: Shadowing the variable guess, it parses the string into an unsigned 32-bit integer. If parsing fails, it prints an error message.
    let guess: u32 = guess.trim().parse().expect("Please type a number!"); ：隐藏变量 guess ，将字符串解析为无符号32位整数。如果解析失败，它将打印一条错误消息。
  • match guess.cmp(&secret_number) { ... }: Compares the user's guess to the secret number using a match statement, handling three cases: less than, greater than, or equal to the secret number.
    第0号：使用 match 语句将用户的猜测与秘密数字进行比较，处理三种情况：小于、大于或等于秘密数字。

Shadowing: 阴影：

  • Shadowing is when a new variable is declared with the same name as an existing variable, effectively “shadowing” the previous one.
    隐藏是当一个新变量与现有变量同名时，有效地“隐藏”前一个变量。
  • In this code, let guess: u32 = ... is an example of shadowing. The second guess shadows the first one, changing its type from String to u32. Shadowing is often used to reassign a variable with a new value and type while keeping the same name.
    在这段代码中， let guess: u32 = ... 是阴影的一个例子。第二个 guess 隐藏第一个，将其类型从 String 更改为 u32 。隐藏通常用于为变量重新分配新的值和类型，同时保持名称不变。

Step 5 : Looping the guesses till the user wins
第5步：循环猜测，直到用户获胜

In Step 5, the program implements a loop structure to repeatedly prompt the user for guesses until they correctly guess the secret number as we saw in the algorithm
在步骤5中，程序实现了一个循环结构，反复提示用户进行猜测，直到他们正确地猜出密码，就像我们在算法中看到的那样

As always code then explanation :
一如既往的代码然后解释：

use std::io;
use std::cmp::Ordering;
use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);
    println!("Secret number: {}", secret_number);

    loop {
        println!("Please input your guess");

        let mut guess = String::new();

        io::stdin().read_line(&mut guess).expect("Failed to read line");

        let guess: u32 = guess.trim().parse().expect("Please type a number!");
        println!("Your guess: {}", guess);

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            },
        }
    }
}

Running the program: 运行程序：

$ cargo run
Guess the number!
Secret number : 23
Please input your guess
4
Your guess : 4
Too small!
Please input your guess
76
Your guess : 76
Too big!
Please input your guess
23
Your guess : 4
You win!

Explanation: 说明：

  • loop{...} statement is used to create an infinite loop
    loop{...} 语句用于创建无限循环
  • We are using the break statement to exit out of the program when the variables guess and secret_number are the same.
    当变量 guess 和 secret_number 相同时，我们使用 break 语句退出程序。

Step 6 : Handling invalid input
步骤6：处理无效输入

In Step 6, we want to handle invalid inputs and errors because of them. For example : entering a string in the prompt
在第6步中，我们要处理无效输入和由此产生的错误。例如：在提示符中输入字符串

use std::io;
use std::cmp::Ordering;
use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);
    println!("Secret number: {}", secret_number);

    loop {
        println!("Please input your guess");

        let mut guess = String::new();

        io::stdin().read_line(&mut guess).expect("Failed to read line");

        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };
        println!("Your guess: {}", guess);

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            },
        }
    }
}

Running the program: 运行程序：

$ cargo run
Guess the number!
Secret number : 98
Please input your guess
meow
Please input your guess
43
Your guess : 43
Too small!

Parse User Input: 解析用户输入：

  • Attempts to parse the string in guess into an unsigned 32-bit integer.
    尝试将 guess 中的字符串解析为无符号32位整数。
  • Uses the trim method to remove leading and trailing whitespaces from the user's input.
    使用 trim 方法从用户输入中删除前导和尾随空格。

Match Statement: 匹配声明：

  • The match statement checks the result of the parsing operation.
    match 语句检查解析操作的结果。
  • Ok(num) => num: If parsing is successful, assigns the parsed number to the variable guess.
    Ok(num) => num ：如果解析成功，将解析后的数字赋给变量 guess 。

Error Handling: 错误处理：

  • Err(_) => continue: If an error occurs during parsing, the placeholder '_' matches any error, and the code inside the loop continues, prompting the user for input again.
    第0号：如果在解析过程中出现错误，占位符'_'将匹配任何错误，循环中的代码将继续执行，提示用户再次输入。

Summary 总结

In this article, we embarked on our third day of learning Rust by building a guessing game. Here’s a summary of the key steps and concepts covered:Introduction
在本文中，我们通过构建一个猜谜游戏开始了学习Rust的第三天。以下是所涵盖的关键步骤和概念的摘要：简介

  • The goal is to create a game where the user guesses a randomly generated number between 1 and 100.
    我们的目标是创建一个游戏，让用户猜测1到100之间随机生成的数字。

Algorithm 算法

  • A generic algorithm was outlined, providing a high-level overview of the game’s logic.
    概述了一个通用算法，提供了游戏逻辑的高级概述。

Step 1: Set up a new project
步骤1：创建一个新项目

  • Used cargo new to create a new Rust project named "guessing_game."
    使用 cargo new 创建一个名为“guessing_game”的新Rust项目。“

Step 2: Declaring variables and reading user input
步骤2：声明变量并阅读用户输入

  • Introduced basic input/output functionality using std::io.
    使用 std::io 引入基本输入/输出功能。
  • Demonstrated reading user input, initializing variables, and printing messages.
    演示了阅读用户输入、初始化变量和打印消息。

Step 3: Generating a random number
步骤3：生成随机数

  • Added the rand crate as a dependency to generate random numbers.
    添加了 rand crate作为依赖项来生成随机数。
  • Used rand::thread_rng().gen_range(1..=100) to generate a random number between 1 and 100.
    使用 rand::thread_rng().gen_range(1..=100) 生成1到100之间的随机数。

Step 4: Comparing the guess to the user input
步骤4：将猜测与用户输入进行比较

  • Introduced variable shadowing and compared user input to the secret number.
    引入了变量跟踪，并将用户输入与秘密数字进行比较。
  • Used a match statement to handle different comparison outcomes.
    使用 match 语句处理不同的比较结果。

Step 5: Looping the guesses till the user wins
第5步：循环猜测，直到用户获胜

  • Implemented a loop structure to allow the user to make repeated guesses until they correctly guess the secret number.
    实现了一个循环结构，允许用户重复猜测，直到他们正确地猜测秘密数字。

Step 6: Handling invalid input
步骤6：处理无效输入

  • Addressed potential errors by adding error handling to the user input parsing process.
    通过向用户输入分析过程添加错误处理来解决潜在错误。
  • Used the continue statement to skip the current iteration and prompt the user again in case of an error.
    使用 continue 语句跳过当前迭代，并在出现错误时再次提示用户。

Final code : 最终代码：

use std::io;
use std::cmp::Ordering;
use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    loop {
        println!("Please input your guess");

        let mut guess = String::new();

        io::stdin().read_line(&mut guess).expect("Failed to read line");

        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };
        println!("Your guess: {}", guess);

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            },
        }
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1588492.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

数据生成 | Matlab实现基于SNN浅层神经网络的数据生成

数据生成 | Matlab实现基于SNN浅层神经网络的数据生成

数据生成 | Matlab实现基于SNN浅层神经网络的数据生成 目录 数据生成 | Matlab实现基于SNN浅层神经网络的数据生成生成效果基本描述模型描述程序设计参考资料 生成效果 基本描述 1.Matlab实现基于SNN浅层神经网络的数据生成&#xff0c;运行环境Matlab2021b及以上&#xff1b; …
阅读更多...
微软卡内基梅隆大学：无外部干预，GPT4等大语言模型难以自主探索

微软卡内基梅隆大学：无外部干预，GPT4等大语言模型难以自主探索

目录 引言&#xff1a;LLMs在强化学习中的探索能力探究 研究背景&#xff1a;LLMs的在情境中学习能力及其重要性 实验设计&#xff1a;多臂老虎机环境中的LLMs探索行为 实验结果概览&#xff1a;LLMs在探索任务中的普遍失败 成功案例分析&#xff1a;Gpt-4在特定配置下的探…
阅读更多...
TS在interface和type的区别

TS在interface和type的区别

在TypeScript中&#xff0c;interface和type都是用来定义类型的方式 (1)语法&#xff1a; interface 关键字用于定义接口,一般定义对象类型,可以描述对象的形状&#xff0c;即一个对象应该具有哪些属性和方法。interface可以声明对象应该具有的结构和属性。 type 关键字用于…
阅读更多...
Java 中文官方教程 2022 版（三十二）

Java 中文官方教程 2022 版（三十二）

原文&#xff1a;docs.oracle.com/javase/tutorial/reallybigindex.html 一个基本的打印程序 原文&#xff1a;docs.oracle.com/javase/tutorial/2d/printing/printable.html 本节解释了如何创建一个基本的打印程序&#xff0c;显示打印对话框&#xff0c;并将文本“Hello Worl…
阅读更多...
导入芯片原厂SDK Mirror源码到gerrit

导入芯片原厂SDK Mirror源码到gerrit

下载镜像代码 repo init --mirror --repo-url ssh://xx/repo.git -u ssh://xx/manifests.git -m manifest.xml repo sync 创建AOSP project 对All Project权限修改 创建repo 在刚才下载的codebase根目录执行如下命令&#xff1a; repo forall -c echo $REPO_PROJECT; ssh -p 29…
阅读更多...
Linux使用docker安装RocketMQ并登录管理界面

Linux使用docker安装RocketMQ并登录管理界面

Linux使用docker安装RocketMQ并登录管理界面 1、创建 /opt/rocketmq/docker-compose.yml和/opt/rocketmq/broker.conf两个配置文件 2、docker-compose.yml&#xff0c;并配置管理页面端口为8090 version: 3.5 services:rmqnamesrv:image: foxiswho/rocketmq:servercontainer_…
阅读更多...
Ubuntu 22.04进行远程桌面连接

Ubuntu 22.04进行远程桌面连接

文心一言 Ubuntu 22.04进行远程桌面连接&#xff0c;无论是连接到Windows 10还是另一个Ubuntu 22.04&#xff0c;都可以通过不同的方式实现。以下是具体的步骤&#xff1a; 连接到Windows 10 在Windows 10上开启远程桌面功能&#xff1a;首先&#xff0c;需要在Windows 10上…
阅读更多...
linux系统特殊符号

linux系统特殊符号

分号可以对命令分割&#xff0c;如下图&#xff0c;单独使用ls与pwd&#xff0c;与使用分号进行分割 井号可以将后面内容注释掉&#xff0c;以及作为root身份提示符 $可以取出变量的值&#xff0c;同时也是普通用户身份提示符 反斜杠可以将特殊字符转义为普通字符 花括号可以用…
阅读更多...
（五）PostgreSQL的管理工具pgAdmin

（五）PostgreSQL的管理工具pgAdmin

PostgreSQL的管理工具pgAdmin pgAdmin 是一款流行的开源图形界面管理工具&#xff0c;用于 PostgreSQL 数据库的管理和开发。它提供了一个易于使用的界面&#xff0c;允许用户执行各种数据库任务&#xff0c;如创建和修改数据库对象&#xff08;表、视图、索引等&#xff09;、…
阅读更多...
一文看懂标准版和Pro版的区别

一文看懂标准版和Pro版的区别

在CRMEB的众多产品中&#xff0c;有这样两款产品经常被拿来比较&#xff0c;它们就是CRMEB的标准版和Pro版商城系统&#xff0c;今天&#xff0c;我们就来盘一下这两款系统之间究竟有哪些不同。 1、Pro版系统性能更卓越 CRMEB Pro版采用Tp6 SwooleRedis高性能框架开发&#…
阅读更多...
组件与组件之间的传递-事件总线

组件与组件之间的传递-事件总线

两个组件之间的数据传递&#xff08;属于非父子组件通讯&#xff09; 当项目中只是两个组件的少量数据传递时使用事件总线这种方法会比较方便&#xff0c;但当遇到大量数据传递时推荐使用vuex 思路 组件与组件之间不能直接传递&#xff0c;这是候可以创建一个EventBus.js文件…
阅读更多...
【火猫TV】Spirit.Collapse-不清楚队伍的问题出在哪里

【火猫TV】Spirit.Collapse-不清楚队伍的问题出在哪里

1、近日Spirit战队三号位选手Collapse在精英联赛期间接受采访时表示&#xff1a;不清楚队伍目前的问题出在哪里&#xff0c;可能只是因为我们如今的状态和表现都不太好吧。转载&#xff1a;火猫TV资讯 【队伍目前的问题】 “我不是很清楚目前我们的问题出在哪里&#xff0c;可…
阅读更多...
2024年，怎么开通一个属于自己的抖店？

2024年，怎么开通一个属于自己的抖店？

我是王路飞。 抖店&#xff0c;依旧是普通人做抖音最好的渠道。 至于短视频直播带货&#xff0c;门槛较高&#xff0c;尤其是在当前的环境下&#xff0c;个人是很难竞争的过那些达人团队的。 不管是在门槛、操作、还是利润回报等方面&#xff0c;抖店都是一个不错的选择。 …
阅读更多...
奎芯科技：智能时代的芯片上游企业如何突破？

奎芯科技：智能时代的芯片上游企业如何突破？

半导体IP&#xff08;Intellectual Property&#xff0c;知识产权&#xff09;&#xff0c;通常也称作IP核&#xff08;IP core&#xff09;&#xff0c;指芯片设计中预先设计、验证好的功能模块&#xff0c;主要服务于芯片设计&#xff0c;因部分通用功能模块在芯片中被反复使…
阅读更多...
五：函数基础：概念、基础语法、库函数与自定义函数

五：函数基础：概念、基础语法、库函数与自定义函数

本章学习链接如下&#xff1a; 1.函数的概念 函数是执行特定任务的自包含代码块&#xff0c;它可以接受输入&#xff0c;处理输入&#xff0c;并产生输出。函数的使用提高了代码的重用性、模块性和可读性。C语言中的函数可以分为两大类&#xff1a;库函数和用户定义函数。 2.函…
阅读更多...
为什么程序员老婆都很漂亮？网友：new出来的。。。

为什么程序员老婆都很漂亮？网友：new出来的。。。

最近&#xff0c;我被一个问题吸引了&#xff0c;一网友提问&#xff1a;“为何程序员老婆都很漂亮&#xff1f;”哈哈&#xff0c;说到这个话题&#xff0c;我瞬间就不困了。 评论区的网友们也非常来劲儿。有位网友打趣说&#xff1a;“因为是自己用代码new出来的&#xff0c;…
阅读更多...
换换换 码题集

换换换 码题集

难度:钻石 时间限制:1秒 占用内存:128M 输入 5 5 5 car van track dog cat 1 2 4 5 3 2 5 1 1 4 van car track dog cat 输出 5 3 2 4 1 原始思路&#xff1a;for循环&#xff0c;但会运行超时 #include<bits/stdc.h> using namespace std; int main(){int n,m,t;cin…
阅读更多...
校园论坛系统

校园论坛系统

文章目录 校园论坛系统一、项目演示二、项目介绍三、10000字论文参考四、系统部分功能截图五、部分代码展示六、底部获取项目和10000字论文参考&#xff08;9.9&#xffe5;&#xff09; 校园论坛系统 一、项目演示 校园论坛系统 二、项目介绍 基于springbootvue的前后端分离…
阅读更多...
网上一个叫阳哥的网红分享的人力RPO项目靠谱吗？

网上一个叫阳哥的网红分享的人力RPO项目靠谱吗？

在抖音平台上&#xff0c;阳哥以其专业的知识和独到的见解&#xff0c;吸引了大量粉丝的关注。最近&#xff0c;他分享的人力RPO项目更是引起了广泛关注。那么&#xff0c;阳哥介绍的这个人力RPO项目到底靠不靠谱呢?本文将从四个方面进行分析和佐证。 首先&#xff0c;阳哥作为…
阅读更多...
ARM/X86+FPGA轨道交通/工程车辆行业的解决方案

ARM/X86+FPGA轨道交通/工程车辆行业的解决方案

深圳推出首条无人驾驶地铁—深圳地铁20号线&#xff0c;可以说是深圳地铁的一次开创性的突破。智能交通不断突破的背后&#xff0c;需要很严格的硬件软件等控制系 统&#xff1b;地铁无人驾驶意味着信号系统、通信系统、综合监控系统、站台屏蔽门工程等项目必须严格执行验收。…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023