ट्रैक
/
C#
C#
/
अभ्यास
/
कारें, इकट्ठी हों!
कारें, इकट्ठी हों!

कारें, इकट्ठी हों!

सीखने का अभ्यास

परिचय

संख्याएँ

C# में दो तरह की संख्याएँ होती हैं:

  • पूर्णांक: ऐसी संख्याएँ जिनमें दशमलव चिह्न के बाद कोई अंक नहीं होता (पूर्ण संख्याएँ)। जैसे -6, 0, 1, 25, 976 और 500000।
  • दशमलव संख्याएँ: ऐसी संख्याएँ जिनमें दशमलव चिह्न के बाद शून्य या उससे अधिक अंक होते हैं। जैसे -2.4, 0.1, 3.14, 16.984025 और 1024.0।

C# में सबसे आम दो संख्यात्मक टाइप int और double हैं। int एक 32-बिट पूर्णांक है और double एक 64-बिट दशमलव संख्या।

अंकगणित के लिए मानक अंकगणितीय ऑपरेटर इस्तेमाल किए जाते हैं। संख्याओं की तुलना मानक संख्यात्मक तुलना ऑपरेटरों और समानता (==) तथा असमानता (!=) ऑपरेटरों से की जा सकती है।

C# में संख्यात्मक रूपांतरण दो तरह के होते हैं:

  1. अंतर्निहित रूपांतरण: इसमें कोई डेटा नहीं खोता और किसी अतिरिक्त सिंटैक्स की ज़रूरत नहीं होती।
  2. स्पष्ट रूपांतरण: इसमें डेटा खो सकता है, और इसके लिए कास्ट के रूप में अतिरिक्त सिंटैक्स लिखना पड़ता है।

चूँकि एक int में double से कम परिशुद्धता होती है, इसलिए int से double में रूपांतरण सुरक्षित है और वह अंतर्निहित रूपांतरण है। लेकिन double से int में रूपांतरण का मतलब डेटा खोना हो सकता है, इसलिए उसके लिए स्पष्ट रूपांतरण ज़रूरी है।

int softCool = 1358938113;
double notLost = 4.8151623;

// implicit cast: no loss of information
double macDebug = softCool;         // 1358938113.0

// explicit cast: possible loss of information 
int somethingLost = (int)notLost;   // 4

if स्टेटमेंट

इस अभ्यास में आपको शर्त के अनुसार कोड चलाना है। C# में ऐसा करने का सबसे आम तरीका if/else स्टेटमेंट का इस्तेमाल है:

int x = 6;

if (x == 5)
{
    // Execute logic if x equals 5
}
else if (x > 7)
{
    // Execute logic if x greater than 7
}
else
{
    // Execute logic in all other cases
}

किसी if स्टेटमेंट की शर्त का टाइप bool होना चाहिए। C# में truthy वैल्यू की कोई अवधारणा नहीं होती।

निर्देश

इस अभ्यास में आप एक कार फैक्ट्री की असेंबली लाइन के उत्पादन का विश्लेषण करने के लिए कोड लिखेंगे। असेंबली लाइन की गति 0 (बंद) से 10 (अधिकतम) तक हो सकती है।

सबसे कम गति (1) पर हर घंटे 221 कारें बनती हैं। गति बढ़ने के साथ उत्पादन भी एक समान अनुपात में बढ़ता है। इसलिए गति 4 पर हर घंटे 4 * 221 = 884 कारें बननी चाहिए। लेकिन तेज़ गति से खराब कारें बनने की संभावना बढ़ जाती है, जिन्हें फिर हटाना पड़ता है।

आपके सामने तीन काम हैं।

1. सफलता दर की गणना कीजिए

किसी दी गई गति पर बिना किसी गड़बड़ी के आइटम बनने के अनुपात की गणना करने के लिए (static) AssemblyLine.SuccessRate() मेथड को लागू कीजिए। नीचे दी गई तालिका दिखाती है कि गति सफलता दर को कैसे प्रभावित करती है:

  • 0: 0% सफलता दर।
  • 1 से 4: 100% सफलता दर।
  • 5 से 8: 90% सफलता दर।
  • 9: 80% सफलता दर।
  • 10: 77% सफलता दर।
AssemblyLine.SuccessRate(10)
// => 0.77

2. प्रति घंटे उत्पादन दर की गणना कीजिए

असेंबली लाइन की सफलता दर को ध्यान में रखते हुए उसकी प्रति घंटे उत्पादन दर की गणना करने के लिए (static) AssemblyLine.ProductionRatePerHour() मेथड को लागू कीजिए:

AssemblyLine.ProductionRatePerHour(6)
// => 1193.4

ध्यान रखिए कि लौटाई गई वैल्यू एक double है।

3. प्रति मिनट बनने वाले काम करने योग्य आइटम की संख्या की गणना कीजिए

यह गणना करने के लिए कि हर मिनट कितनी काम करने योग्य कारें बनती हैं, (static) AssemblyLine.WorkingItemsPerMinute() मेथड को लागू कीजिए:

AssemblyLine.WorkingItemsPerMinute(6)
// => 19

ध्यान रखिए कि लौटाई गई वैल्यू एक int है।

GitHub के ज़रिए संपादित करें यह लिंक एक नई विंडो या टैब में खुलता है
C# Exercism

कारें, इकट्ठी हों! शुरू करने के लिए तैयार हैं?

Exercism पर साइन अप कीजिए और C# को 62 कॉन्सेप्ट178 अभ्यास तथा असली इंसानों से मिलने वाली मेंटरिंग के साथ सीखिए और उसमें महारत हासिल कीजिए, वह भी बिल्कुल मुफ्त।