- ตัวดำเนินการ
-
เรียนรู้
เรียน Python ตัวอย่างที่รันได้, NumPy, pandas และอื่น ๆ เรียน AIโครงข่ายประสาท ML และ LLM ตั้งแต่ศูนย์ เรียน C และ C++ พอยน์เตอร์ หน่วยความจำ STL และ C++ สมัยใหม่ เรียน C#พื้นฐาน C#, OOP, LINQ, async และแบบฝึกหัด .NET เรียน Matplotlibกราฟเส้น แท่ง กระจาย และวงกลม พร้อมตัวแสดงภาพแบบโต้ตอบ อัลกอริทึม Python การค้นหา การเรียงลำดับ รีเคอร์ชัน และภาพจำลอง O(n) อัลกอริทึม C และ C++ เปรียบเทียบการเขียนด้วย C และ C++ เขียนโปรแกรมสำหรับเด็ก เรียนเขียนโปรแกรมผ่านการเล่น!
- โจทย์ใหม่
- สำหรับครูใหม่
- อัปเดต
- เลี้ยงกาแฟสักแก้ว
Return a copy of the list with its first and last elements swapped. Lists with fewer than two elements stay the same.
Implement swap_first_last(items).
Input
items: The list of integers.
Output
Return the list with the ends swapped.
เงื่อนไข
0 ≤ length ≤ 100,000
ตัวอย่าง
ตัวอย่างที่ 1
อินพุต:
items = [1, 2, 3, 4]
ผลลัพธ์ที่คาดหวัง:
[4, 2, 3, 1]คำอธิบาย
1 and 4 trade places: [4, 2, 3, 1].
ตัวอย่างที่ 2
อินพุต:
items = [9]
ผลลัพธ์ที่คาดหวัง:
[9]คำอธิบาย
A single item has nothing to swap with: [9].
แหล่งอ้างอิง
-
ตัวอย่างที่ 1 ยังไม่ได้รันอินพุต:
items = [1, 2, 3, 4]ผลลัพธ์ที่คาดหวัง:[4, 2, 3, 1]เอาต์พุตของคุณ -
ตัวอย่างที่ 2 ยังไม่ได้รันอินพุต:
items = [9]ผลลัพธ์ที่คาดหวัง:[9]เอาต์พุตของคุณ
มี 4 การทดสอบที่ซ่อนอยู่จะถูกรันเมื่อคุณส่งคำตอบ ถ้าโค้ดไม่ผ่านข้อใด คุณจะเห็นการทดสอบข้อนั้น แก้โจทย์ให้ได้เพื่อดูทั้งหมด
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.
🚀 252,702 การดำเนินการทั้งหมด (135 ในเดือนนี้)
ฝึก Rust ด้วยโจทย์เขียนโค้ด
แก้โจทย์จริงใน editor นี้: รันทดสอบตัวอย่าง ส่งคำตอบ และรับรีวิวโค้ดจาก AI
🦀 เกี่ยวกับตัวรัน Rust ออนไลน์นี้
CodeUtility Rust Executor ให้คุณเขียนและรันโค้ด Rust ได้โดยตรงบนเบราว์เซอร์ - ไม่ต้องติดตั้ง ไม่ต้องตั้งค่า toolchain หรือสภาพแวดล้อมในเครื่อง ใช้งานผ่าน sandbox ที่ปลอดภัย รองรับเวอร์ชันคอมไพเลอร์ Rust จริง 1.70, 1.72, 1.73, และ 1.74
เครื่องมือนี้จะคอมไพล์และรันโปรแกรม Rust ของคุณบนคลาวด์ด้วยคอมไพเลอร์ rustc จริง
เพื่อให้ผลลัพธ์ถูกต้องและสม่ำเสมอ คุณสามารถทดลองใช้งาน variables, ownership, borrowing,
pattern matching, traits, generics และฟีเจอร์สมัยใหม่อื่นๆ ของ Rust ได้อย่างง่ายดาย
เหมาะสำหรับการเรียนรู้แนวคิดหลักของ Rust - โดยเฉพาะ memory safety, error handling และ concurrency - โดยไม่ต้องติดตั้ง Cargo หรือเซ็ตอัปใดๆ ในเครื่อง ทุกอย่างรันตรงบนเบราว์เซอร์ของคุณภายในไม่กี่วินาที
มากกว่าเครื่องมือรันโค้ด
ใช้ตัวแก้ไขหลายไฟล์ เทอร์มินัลประมวลผลแบบแยกส่วน ไลบรารีเฉพาะรันไทม์ พื้นที่ทำงานถาวร การแชร์ และการทำงานร่วมกันแบบเรียลไทม์ได้จากตัวประมวลผลเดียวกัน
วิธีใช้ตัวประมวลผลนี้
เลือกรันไทม์ เปิดหรือสร้างไฟล์ เขียนโค้ด แล้วเลือกเรียกใช้ ผลลัพธ์จะแสดงในเทอร์มินัล ส่วนผู้ใช้ที่ลงชื่อเข้าใช้สามารถเก็บไฟล์ในพื้นที่ทำงาน ติดตั้งไลบรารี และทำงานร่วมกันผ่านการแชร์ได้
- เลือกเวอร์ชันแล้วแก้ไขไฟล์ปัจจุบัน หรือเปิดไฟล์อื่นในพื้นที่ทำงาน
- เรียกใช้โค้ด ป้อนข้อมูลในเทอร์มินัลเมื่อระบบร้องขอ และตรวจสอบประวัติการเรียกใช้ที่บันทึกไว้
- ใช้ไลบรารี เครื่องมือพื้นที่ทำงาน การแชร์ และแชท เมื่องานของคุณต้องใช้โค้ดมากกว่าหนึ่งส่วน
💡 พื้นฐาน Rust และตัวอย่างที่คุณลองได้ด้านบน
1. การประกาศตัวแปรและค่าคงที่
ใช้ let ในการประกาศตัวแปร ใช้ const สำหรับค่าคงที่ และใช้ mut สำหรับตัวแปรที่แก้ไขค่าได้
let x = 10;
let pi: f64 = 3.14;
let name = "Alice";
let is_active = true;
const MAX_USERS: u32 = 100;2. เงื่อนไข (if / match)
Rust ใช้ if สำหรับเงื่อนไข และใช้ match สำหรับ pattern matching
let x = 2;
if x == 1 {
println!("หนึ่ง");
} else if x == 2 {
println!("สอง");
} else {
println!("อื่น");
}
match x {
1 => println!("หนึ่ง"),
2 => println!("สอง"),
_ => println!("อื่น"),
}3. ลูป
Rust รองรับ for, while และ loop สำหรับลูปไม่รู้จบ
for i in 0..3 {
println!("{}", i);
}
let mut n = 3;
while n > 0 {
println!("{}", n);
n -= 1;
}4. อาร์เรย์
อาร์เรย์ขนาดคงที่ใน Rust ใช้วงเล็บเหลี่ยม ใช้ slices เพื่อดูบางส่วนของข้อมูล
let nums = [10, 20, 30];
println!("{}", nums[1]);5. เวกเตอร์ (อาร์เรย์แบบไดนามิก)
Vec ใช้สำหรับอาร์เรย์แบบไดนามิก
let mut fruits = vec!["apple", "banana"];
fruits.push("cherry");
fruits.pop();
for fruit in &fruits {
println!("{}", fruit);
}6. อินพุต/เอาต์พุตผ่านคอนโซล
ใช้ println! สำหรับเอาต์พุต และใช้ std::io สำหรับอินพุต
use std::io;
let mut name = String::new();
println!("กรอกชื่อของคุณ:");
io::stdin().read_line(&mut name).unwrap();
println!("สวัสดี, {}", name.trim());7. ฟังก์ชัน
ฟังก์ชันใช้ fn และสามารถคืนค่าได้ด้วย ->
fn greet(name: &str) -> String {
format!("สวัสดี, {}", name)
}
println!("{}", greet("Alice"));8. HashMap
ใช้ std::collections::HashMap สำหรับข้อมูลแบบคีย์-ค่า
use std::collections::HashMap;
let mut person = HashMap::new();
person.insert("name", "Bob");
println!("{}", person["name"])9. การจัดการข้อผิดพลาด
Rust จัดการข้อผิดพลาดด้วย Result และ match หรือ unwrap()
fn fail() -> Result<(), String> {
Err("มีบางอย่างผิดพลาด".to_string())
}
match fail() {
Ok(_) => println!("สำเร็จ"),
Err(e) => println!("{}", e),
}10. การทำงานกับไฟล์ (File I/O)
ใช้ std::fs เพื่ออ่านและเขียนไฟล์
use std::fs;
fs::write("file.txt", "สวัสดีไฟล์").unwrap();
let content = fs::read_to_string("file.txt").unwrap();
println!("{}", content);11. การจัดการสตริง
สตริงใน Rust ถูกจัดเก็บบน heap และมีเมธอดให้ใช้งานมากมาย
let mut text = String::from(" Hello Rust ");
println!("{}", text.trim());
println!("{}", text.to_uppercase());
text = text.replace("Hello", "Hi");
println!("{}", text);12. Struct และ Methods
Rust ใช้ struct สำหรับประเภทข้อมูล และใช้ impl สำหรับเมธอด
struct Person {
name: String,
}
impl Person {
fn greet(&self) -> String {
format!("สวัสดี ฉันชื่อ {}", self.name)
}
}
let p = Person { name: "Alice".to_string() };
println!("{}", p.greet());13. การอ้างอิงและการยืม
Rust ใช้ & เพื่อ borrow ค่า และใช้ &mut สำหรับการอ้างอิงที่แก้ไขค่าได้
fn update(x: &mut i32) {
*x += 1;
}
let mut value = 10;
update(&mut value);
println!("{}", value);