CodeUtility
कोडिंग को डेवलपर्स के लिए आसान बनाना।!

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 का अभ्यास करें

सीधे इस एडिटर में प्रैक्टिकल समस्याएँ हल करें: सैंपल टेस्ट चलाएँ, सबमिट करें, और AI कोड रिव्यू पाएं।

सभी Rust चैलेंज
आसान

Rectangle Perimeter

Compute the perimeter of a rectangle from its sides.

आप सीखेंगे अंकगणितलौटाए गए मान
BeginnerLearning-pathVariables
Python C++ C# Java JavaScript Go Rust Kotlin Swift
12 हल
12 समाधान देखें
आसान

Distance Between Points

Compute the straight-line distance between two points.

आप सीखेंगे पाइथागोरस प्रमेयवर्गमूल
BeginnerFunctionsLearning-pathmath
Python C++ C# Swift Java JavaScript Go Rust Kotlin
7 हल
7 समाधान देखें
आसान

Average of Three

Average three whole numbers.

आप सीखेंगे अंकगणितभाग
BeginnerLearning-pathVariables
Python C++ C# Java JavaScript Go Rust Kotlin Swift
6 हल
6 समाधान देखें
आसान

दो वेक्टरों का डॉट प्रोडक्ट

दो वेक्टरों के हर तत्व को आपस में गुणा करके परिणाम जोड़ें, यही हर न्यूरॉन की मूल गणना है।

आप सीखेंगे वेक्टरडॉट प्रोडक्ट
न्यूरल नेटवर्कएआईमशीन लर्निंग
Python C++ C# Java JavaScript Go Rust Kotlin Swift
4 हल
4 समाधान देखें
आसान

Largest of Three

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

आप सीखेंगे तुलनाशर्तें जोड़ना
BeginnerConditionsLearning-path
Python C++ C# Java JavaScript Go Rust Kotlin Swift
4 हल
4 समाधान देखें
आसान

मूल संख्या जांचें

निर्धारित करें कि कोई संख्या मूल है या नहीं।

आप सीखेंगे विभाज्यतालूप को तेज़ करना
BeginnerLoopsNumbersStudent-beginner
Kotlin Swift Python C++ C# Java JavaScript Go Rust
3 हल
3 समाधान देखें
आसान

Number Triangle

Build a triangle of increasing numbers.

आप सीखेंगे बढ़ती पंक्तियाँपंक्तियों के पार काउंटर
BeginnerLearning-pathNested-loopsPatterns
Python C++ C# Java JavaScript Go Rust Kotlin Swift
3 हल
3 समाधान देखें
आसान

आर्मस्ट्रॉन्ग संख्या

जांचें कि कोई संख्या अपने अंकों की संख्या की घात में उठाए गए अंकों के योग के बराबर है या नहीं।

आप सीखेंगे अंक निकालनाघात
BeginnerNumbersStudent-beginner
JavaScript Python C++ C# Java Go Rust Kotlin Swift
3 हल
3 समाधान देखें
आसान

Row Sums

Add up every row of a grid.

आप सीखेंगे 2D सूचियाँनेस्टेड लूप
BeginnerGridsLearning-path
Python C++ C# Java JavaScript Go Rust Kotlin Swift
3 हल
3 समाधान देखें
आसान

Min and Max Together

Find the smallest and largest value in one pass.

आप सीखेंगे एक ही पासकई मान लौटाना
ArraysBeginnerFunctionsLearning-path
Python C++ C# Java JavaScript Go Rust Kotlin Swift
3 हल
3 समाधान देखें
आसान

Count Pairs With a Sum

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

आप सीखेंगे इंडेक्स के जोड़ेदोहरी गिनती से बचना
ArraysBeginnerLearning-pathNested-loops
Python C++ C# Java JavaScript Go Rust Kotlin Swift
3 हल
3 समाधान देखें
आसान

Hollow Square

Draw the outline of a square with * characters.

आप सीखेंगे किनारे पहचाननास्ट्रिंग बनाना
BeginnerLearning-pathNested-loopsPatterns
Python C++ C# Swift Java JavaScript Go Rust Kotlin
3 हल
3 समाधान देखें

🦀 इस Rust ऑनलाइन एक्ज़ीक्यूटर के बारे में

CodeUtility Rust Executor आपको अपने ब्राउज़र में सीधे Rust कोड लिखने और चलाने देता है - किसी इंस्टॉलेशन, टूलचेन सेटअप, या लोकल एनवायरनमेंट की जरूरत नहीं। यह एक सुरक्षित सैंडबॉक्स द्वारा संचालित है जो असली Rust कंपाइलर संस्करण 1.70, 1.72, 1.73, और 1.74 को सपोर्ट करता है।

यह टूल क्लाउड में वास्तविक rustc कंपाइलर का उपयोग करके आपके Rust प्रोग्राम्स को कम्पाइल और रन करता है, जिससे सटीक और एकसमान परिणाम मिलते हैं। आप वेरिएबल्स, ओनरशिप, बॉरोइंग, पैटर्न मैचिंग, ट्रेट्स, जेनरिक्स, और अन्य आधुनिक Rust फीचर्स के साथ आसानी से प्रयोग कर सकते हैं।

Rust की मूल अवधारणाएँ सीखने के लिए यह आदर्श है - खासकर मेमोरी सेफ़्टी, एरर हैंडलिंग, और कंकरेन्सी - और इसके लिए आपको Cargo इंस्टॉल करने या कोई लोकल सेटअप करने की ज़रूरत नहीं। सब कुछ कुछ ही सेकंड में सीधे आपके ब्राउज़र में चलता है।

सिर्फ़ एक कोड रनर से कहीं अधिक

एक ही एक्ज़ीक्यूटर में मल्टी-फ़ाइल एडिटर, अलग-थलग निष्पादन टर्मिनल, रनटाइम-विशिष्ट लाइब्रेरी, स्थायी वर्कस्पेस, साझाकरण और रीयल-टाइम सहयोग का उपयोग करें।

इस एक्ज़ीक्यूटर का उपयोग कैसे करें?

रनटाइम चुनें, फ़ाइल खोलें या बनाएँ, अपना कोड लिखें और चलाएँ चुनें। आउटपुट टर्मिनल में दिखाई देता है। साइन-इन उपयोगकर्ता वर्कस्पेस में फ़ाइलें रख सकते हैं, लाइब्रेरी इंस्टॉल कर सकते हैं और शेयर के माध्यम से सहयोग कर सकते हैं।

  1. एक संस्करण चुनें और वर्तमान फ़ाइल संपादित करें या वर्कस्पेस की दूसरी फ़ाइल खोलें।
  2. कोड चलाएँ, माँगे जाने पर टर्मिनल में इनपुट दें और सहेजा गया रन इतिहास देखें।
  3. जब कार्य के लिए एक से अधिक कोड अंश चाहिए, तो लाइब्रेरी, वर्कस्पेस टूल, शेयरिंग और चैट का उपयोग करें।

💡 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 का उपयोग करता है।

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!["सेब", "केला"];
fruits.push("चेरी");
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. हैशमैप्स

कुंजी-मूल्य डेटा के लिए 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. फ़ाइल 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 में स्ट्रिंग्स हीप पर एलोकेट होती हैं और कई मेथड्स सपोर्ट करती हैं।

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

12. स्ट्रक्ट्स और मेथड्स

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 मान उधार लेने के लिए & और परिवर्तनशील रेफ़रेंस के लिए &mut का उपयोग करता है।

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

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