লো-পাওয়ার এমবেডেড গেম

// pointless but legal
let unit = ();
// single element
let single_element = ("note the comma",);
// two element
let two_element = (123, "elements can be of differing types");

let (elem1, _elem2) = two_element;
assert_eq!(elem1, 123);

let notation = single_element.0;
assert_eq!(notation, "note the comma");

struct TupleStruct(u8, i32);
let my_tuple_struct = TupleStruct(123, -321);
let neg = my_tuple_struct.1;
let TupleStruct(byte, _) = my_tuple_struct;
assert_eq!(neg, -321);
assert_eq!(byte, 123);

// fails due to private fields
mod tuple { pub struct TupleStruct(u8, i32); }
fn main() { let _my_tuple_struct = tuple::TupleStruct(123, -321); }

// succeeds: fields are public
mod tuple { pub struct TupleStruct(pub u8, pub i32); }
fn main() { let _my_tuple_struct = tuple::TupleStruct(123, -321); }

নির্দেশনা

আপনি একটি লো-পাওয়ার এমবেডেড সিস্টেমের জন্য একটি গেম নিয়ে কাজ করছেন এবং গেমের অন্যান্য অংশে ব্যবহারের জন্য কয়েকটি সুবিধাজনক ফাংশন লিখতে হবে।

1. একটি ভাগের ভাগফল ও ভাগশেষ নির্ণয় করুন

ভাগফল হলো একটি ভাগের আউটপুট।

fn divmod(dividend: i16, divisor: i16) -> (i16, i16)

উদাহরণ:

assert_eq!(divmod(10, 3), (3, 1));

2. একটি ইটারেটর থেকে জোড় অবস্থানের আইটেম বাছাই করুন

এটি একটি স্ক্রিন-বাফার অপটিমাইজেশন চালু করতে সাহায্য করবে, আপনার বস প্রতিশ্রুতি দিয়েছেন।

ইটারেটর হলো এমন আইটেম, যেগুলো Iterator ট্রেইট দ্বারা সংজ্ঞায়িত মেথডগুলো প্রকাশ করে। সেই ডকুমেন্টেশন বেশ বিস্তৃত, কারণ এগুলো অনেক মেথড দেয়; এখানে সবচেয়ে প্রাসঙ্গিক কিছু বৈশিষ্ট্য দেওয়া হলো:

• একটি ইটারেটর হলো আইটেমের একটি যেকোনো-দৈর্ঘ্যের স্ট্রিম
• এগুলোর একটি enumerate মেথড আছে, যা প্রতিটি মানের জন্য একটি টাপল (i, val) রিটার্ন করে
• এগুলোর একটি filter মেথড আছে, যা একটি ক্লোজার ব্যবহার করে ঠিক করে যে ইটারেটরের একটি এলিমেন্ট দেবে কি না
• এগুলোর একটি map মেথড আছে, যা একটি ক্লোজার ব্যবহার করে ইটারেটরের এলিমেন্টগুলো পরিবর্তন করে

যেহেতু আপনার ফাংশন যেকোনো ধরনের ইটারেটরে রান করতে পারে, তাই এটি বোঝাতে impl ব্যবহার করে যে এটি একটি সাধারণ আইটেম নয়, বরং একটি ট্রেইট ইনস্ট্যান্স। একইভাবে, <Item=T> সিনট্যাক্সের মানে শুধু এই যে ইটারেটরটি কোন ধরনের আইটেম তৈরি করে সেটা গুরুত্বপূর্ণ নয়; আপনার ফাংশন যেকোনো ইটারেটরের জোড় অবস্থানের এলিমেন্ট তৈরি করতে পারবে।

fn evens<T>(iter: impl Iterator<Item=T>) -> impl Iterator<Item=T>

উদাহরণ:

let mut even_ints = evens(0_u8..);
assert_eq!(even_ints.next(), Some(0));
assert_eq!(even_ints.next(), Some(2));
assert_eq!(even_ints.next(), Some(4));
assert_eq!(even_ints.next(), Some(6));

let mut evens_from_odds = evens(1_i16..);
assert_eq!(evens_from_odds.next(), Some(1));
assert_eq!(evens_from_odds.next(), Some(3));
assert_eq!(evens_from_odds.next(), Some(5));
assert_eq!(evens_from_odds.next(), Some(7));

3. মূলবিন্দু থেকে একটি অবস্থানের ম্যানহাটন দূরত্ব নির্ণয় করুন

ম্যাপিংয়ের সুবিধার জন্য আপনার কাছে একটি টাপল স্ট্রাকচার Position আছে:

struct Position(i16, i16);

আপনাকে Position-এর উপর একটি manhattan মেথড ইমপ্লিমেন্ট করতে হবে, যা মূলবিন্দু (Position(0, 0)) থেকে সেই অবস্থানের ম্যানহাটন দূরত্ব রিটার্ন করে।

impl Position {
    fn manhattan(&self) -> i16
}

উদাহরণ:

assert_eq!(Position(3, 4).manhattan(), 7);