जंग में गोल्फ के लिए युक्तियाँ

Question

जबकि Rust कोड गोल्फिंग प्रतियोगिताओं में बहुत कम प्रतिस्पर्धी है, (Java अक्सर छोटा होता है), यह अभी भी गोल्फ में मज़ेदार हो सकता है। Rust code को कम करने के लिए कुछ तरकीबें क्या हैं?

कृपया प्रत्येक उत्तर में केवल एक टिप पोस्ट करें।

Answer 1

कार्यों के बजाय क्लोजर का उपयोग करें

एक बंद:

|n|n+1

एक समारोह से कम है:

fn f(n:i32)->i32{n+1}

---

एक कथन से अधिक समय के लिए ब्रेसिज़ की आवश्यकता होती है, लेकिन फिर भी एक फ़ंक्शन की तुलना में कम होता है।

Answer 2

.Iter () से बचें। enumerate ()

मान लें कि आपके पास कुछ x है जो IntoIterator Trait को लागू करता है और आपको एक फ़ंक्शन f को कॉल करने की आवश्यकता है जो एक तत्व का सूचकांक और एक संदर्भ लेता है। ऐसा करने का मानक तरीका है

x.iter().enumerate().map(f)

इसके बजाय आप कर सकते हैं

(0..).zip(x).map(f)

और अपने आप को न केवल असामान्य रूप से लंबे समय तक बचाने के लिए, बल्कि पुनरावृति के लिए भी कॉल करें!

Answer 3

यदि आपको कई परिवर्तनशील चर की आवश्यकता है, तो यह उन्हें घोषित करने और उन्हें आरंभ करने के लिए बहुत सारे स्थान को बर्बाद कर सकता है, क्योंकि प्रत्येक को मूस कीवर्ड की आवश्यकता होती है और आप = b = c = 0 जैसे कुछ भी नहीं कर सकते। एक समाधान तो एक परिवर्तनशील सरणी घोषित करना है

let mut a=[0;5];

जब भी आप उन्हें एक सामान्य चर के रूप में उपयोग करते हैं, तो आप हर बार 3 अतिरिक्त बाइट खर्च करते हैं:

a[0]+=1;

लेकिन यह अक्सर इसके लायक हो सकता है।

एक ही चाल के लिए टुपल्स का उपयोग करना अक्सर बेहतर विकल्प होता है:

let mut t=(1,4,"this", 0.5, 'c');

यह सरणी के प्रत्येक उपयोग पर एक बाइट को बचाने का लाभ है:

t.0=2

यह उन्हें विभिन्न प्रकार के होने की सुविधा भी देता है। नकारात्मक पक्ष पर, इसे आरंभ करने के लिए अधिक वर्णों की आवश्यकता होती है।

Answer 4

में परिवर्तित &strहो रहा हैString

ये कभी न करें:

s.to_string()  // 13 bytes
s.to_owned()   // 12 bytes

यह हमेशा छोटा होता है:

s.repeat(1)    // 11 bytes

यदि sएक स्ट्रिंग शाब्दिक है:

format!(s)     // 10 bytes

उदाहरण के लिए: 2 बाइट्स को बचाने के format!("")बजाय उपयोग करें String::new()।

यदि प्रकार का निष्कर्ष कार्य करता है:

s.into()       // 8 bytes

Answer 5

उदाहरण के लिए स्ट्रिंग फ़ॉर्मेटिंग का उपयोग करते समय print!(), कोई भी एक आइटम के लिए प्रति प्रारूप एक बाइट को बचाने के लिए गिने और अनावश्यक दोनों प्रकार के फॉर्मेटर्स का उपयोग कर सकता है:

एक उदाहरण के साथ सबसे अच्छा दिखाया:

fn main(){
    print!("{}{}{}. Yes, {0}{}{2}. All you other{1}{2}s are just imitating.",
           "I'm",
           " Slim",
           " Shady",
           " the real");
}

कौन से आउटपुट:

I'm Slim Shady. Yes, I'm the real Shady. All you other Slim Shadys are just imitating.

तो अनिर्दिष्ट फॉर्मेटर्स क्रम में वस्तुओं को सौंपा जाएगा, इससे आप उन पर सूचकांक छोड़ सकते हैं। ध्यान दें कि आप प्रति आइटम प्रारूपित करने के लिए केवल एक अनिर्धारित फॉर्मेटर का उपयोग कर सकते हैं, इसके बाद इसका उपयोग किया जाएगा।

Answer 6

पठन रेखाएँ

विभिन्न बातों पर विचार करने के बाद, मुझे लगता है कि आम तौर पर एक पंक्ति को पुनः प्राप्त करने का सबसे छोटा तरीका है। लाइन में एक नई रेखा है, इसे ट्रिमिंग ( .trim()) द्वारा हटाया जा सकता है या यदि स्लाइस करके नहीं किया जा सकता है।

let y=&mut"".into();std::io::stdin().read_line(y);

कई लाइनों के लिए, linesइटरेटर का उपयोग किया जा सकता है, पुनरावृत्त लाइन न्यूलाइन में समाप्त नहीं होती है। आयात करने के लिए एक ग्लोब आयात की आवश्यकता होती है BufRead, linesजिसे StdinLock<'_>टाइप के लिए उपलब्ध होना चाहिए ।

use std::io::*;let y=stdin();y.lock().lines()

Answer 7

लंघन ट्रेलिंग अर्धविराम

लौटने वाले कार्यों में (), जहां अंतिम अभिव्यक्ति भी प्रकार की है (), आपको अनुगामी की आवश्यकता नहीं है ;:

fn main(){print!("Hello, world!")}

Answer 8

जब उनमें नई लाइनों के साथ तार काम करते हैं, तो आप एक बाइट को बचाते हैं यदि आप स्रोत कोड में एक शाब्दिक रेखा विराम का उपयोग करते हैं बनाम \nस्ट्रिंग में।

println!("Hello
World!");

1 बाइट से कम है:

println!("Hello\nWorld!);

Answer 9

पूरे नंबर फ़्लोटिंग पॉइंट नंबरों का उपयोग करते समय, आप .0एक बाइट को बचाने के लिए अनुगामी को छोड़ सकते हैं ।

let a=1.

1 बाइट से कम है:

let a=1.0