- एक्ज़िक्यूटर्स
-
सीखें
Python सीखें चलने योग्य उदाहरण, NumPy, pandas और बहुत कुछ AI सीखेंन्यूरल नेटवर्क, ML और LLM शुरू से C और C++ सीखें पॉइंटर, मेमोरी, STL और आधुनिक C++ C# सीखेंC# मूल बातें, OOP, LINQ, async और .NET अभ्यास Matplotlib सीखेंलाइन, बार, स्कैटर और पाई चार्ट, इंटरैक्टिव विज़ुअलाइज़र के साथ Python एल्गोरिदम खोज, सॉर्टिंग, रिकर्शन और विज़ुअलाइज़र O(n) C और C++ एल्गोरिदम C और C++ कार्यान्वयन की तुलना करें बच्चों के लिए कोडिंग खेलते-खेलते कोडिंग सीखो!
- चैलेंजनया
- शिक्षकों के लिएनया
- अपडेट्स
- मुझे एक कॉफ़ी पिलाएँ
The grid holds 1 for land and 0 for water. Land cells that touch up, down, left or right belong to the same island. Count the islands; a recursive flood fill is a natural approach.
Implement count_islands(grid).
Input
grid: A rectangular grid of 0s and 1s.
Output
Return the number of islands.
सीमाएँ
0 ≤ rows, columns ≤ 100
उदाहरण
उदाहरण 1
इनपुट:
grid = [
[1, 1, 0, 0],
[0, 1, 0, 1],
[0, 0, 0, 1]
]
अपेक्षित आउटपुट:
2व्याख्या
The top-left group of 3 cells is one island; the two 1s on the right form a second: 2.
उदाहरण 2
इनपुट:
grid = [
[1, 0, 1],
[0, 1, 0]
]
अपेक्षित आउटपुट:
3व्याख्या
Diagonal neighbors don't connect, so each 1 is its own island: 3.
संदर्भ
-
उदाहरण 1 नहीं चलाया गयाइनपुट:
grid = [ [1, 1, 0, 0], [0, 1, 0, 1], [0, 0, 0, 1] ]अपेक्षित आउटपुट:2आपका आउटपुट -
उदाहरण 2 नहीं चलाया गयाइनपुट:
grid = [ [1, 0, 1], [0, 1, 0] ]अपेक्षित आउटपुट:3आपका आउटपुट
सबमिट करने पर 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 का अभ्यास करें
सीधे इस एडिटर में प्रैक्टिकल समस्याएँ हल करें: सैंपल टेस्ट चलाएँ, सबमिट करें, और AI कोड रिव्यू पाएं।
🦀 इस Rust ऑनलाइन एक्ज़ीक्यूटर के बारे में
CodeUtility Rust Executor आपको अपने ब्राउज़र में सीधे Rust कोड लिखने और चलाने देता है - किसी इंस्टॉलेशन, टूलचेन सेटअप, या लोकल एनवायरनमेंट की जरूरत नहीं। यह एक सुरक्षित सैंडबॉक्स द्वारा संचालित है जो असली Rust कंपाइलर संस्करण 1.70, 1.72, 1.73, और 1.74 को सपोर्ट करता है।
यह टूल क्लाउड में वास्तविक rustc कंपाइलर का उपयोग करके आपके Rust प्रोग्राम्स को कम्पाइल और रन करता है,
जिससे सटीक और एकसमान परिणाम मिलते हैं। आप वेरिएबल्स, ओनरशिप, बॉरोइंग, पैटर्न मैचिंग, ट्रेट्स, जेनरिक्स,
और अन्य आधुनिक Rust फीचर्स के साथ आसानी से प्रयोग कर सकते हैं।
Rust की मूल अवधारणाएँ सीखने के लिए यह आदर्श है - खासकर मेमोरी सेफ़्टी, एरर हैंडलिंग, और कंकरेन्सी - और इसके लिए आपको 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 का उपयोग करता है।
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);