परिचय
संख्याएँ
Go में बुनियादी संख्यात्मक टाइप होते हैं, जो पूर्णांक या दशमलव वैल्यू के समूहों को दर्शा सकते हैं।
आपको किस आकार की वैल्यू चाहिए और जिस कंप्यूटर पर प्रोग्राम चल रहा है उसकी आर्किटेक्चर क्या है, इसके अनुसार अलग-अलग टाइप होते हैं (जैसे 32-बिट और 64-बिट)।
इस अभ्यास में आपको केवल इन टाइपों से काम करना होगा:
-
int: जैसे 0, 255, 2147483647।
एक साइन्ड पूर्णांक, जिसका आकार कम से कम 32 बिट होता है (वैल्यू की सीमा: -2147483648 से 2147483647 तक)।
लेकिन यह सिस्टम की आर्किटेक्चर पर निर्भर करता है।
ज़्यादातर आधुनिक कंप्यूटर 64 बिट के होते हैं, इसलिए int का आकार 64 बिट होगा (वैल्यू की सीमा: -9223372036854775808 से 9223372036854775807 तक)।
-
float64: जैसे 0.0, 3.14।
इसमें सभी 64-बिट दशमलव संख्याओं का समूह होता है।
-
uint: जैसे 0, 255।
एक अनसाइन्ड पूर्णांक, जिसका आकार int जितना ही होता है (वैल्यू की सीमा: 32 बिट के लिए 0 से 4294967295 तक और 64 बिट के लिए 0 से 18446744073709551615 तक)
संख्याओं को टाइप कन्वर्ज़न के ज़रिए दूसरे संख्यात्मक टाइपों में बदला जा सकता है।
अंकगणितीय ऑपरेटर
Go कई मानक अंकगणितीय ऑपरेटर सपोर्ट करता है:
| ऑपरेटर |
उदाहरण |
+ |
4 + 6 == 10 |
- |
15 - 10 == 5 |
* |
2 * 3 == 6 |
/ |
13 / 3 == 4 |
% |
13 % 3 == 1 |
पूर्णांक विभाजन में शेषफल छोड़ दिया जाता है (जैसे 5 / 2 == 2)।
ऊपर दिए गए ऑपरेटरों के लिए Go में संक्षिप्त असाइनमेंट होता है (जैसे a += 5, a = a + 5 का संक्षिप्त रूप है)।
Go इंक्रीमेंट और डिक्रीमेंट स्टेटमेंट ++ और -- भी सपोर्ट करता है (जैसे a++)।
टाइपों के बीच बदलाव
टाइपों के बीच बदलाव उस टाइप के नाम वाले फंक्शन से किया जाता है जिसमें बदलना है।
उदाहरण के लिए:
var x int = 42 // x has type int
f := float64(x) // f has type float64 (ie. 42.0)
var y float64 = 11.9 // y has type float64
i := int(y) // i has type int (ie. 11)
अलग-अलग टाइपों पर अंकगणितीय क्रियाएँ
कई भाषाओं में आप अलग-अलग टाइप के वेरिएबलो पर अंकगणितीय क्रियाएँ कर सकते हैं, लेकिन Go में ऐसा करने पर एरर मिलती है।
उदाहरण के लिए:
var x int = 42
// this line produces an error
value := float32(2.0) * x // invalid operation: mismatched types float32 and int
// you must convert int type to float32 before performing arithmetic operation
value := float32(2.0) * float32(x)
निर्देश
इस अभ्यास में आप एक कार फैक्ट्री के उत्पादन का विश्लेषण करने के लिए कोड लिखेंगे।
1. प्रति घंटे बनने वाली काम करने वाली कारों की संख्या निकालिए
कारें एक असेंबली लाइन पर बनती हैं।
असेंबली लाइन की एक खास गति होती है, जिसे बदला जा सकता है।
असेंबली लाइन की गति जितनी तेज़ होती है, उतनी ही ज़्यादा कारें बनती हैं।
लेकिन असेंबली लाइन की गति बदलने से उन कारों की संख्या भी बदल जाती है जो सफलतापूर्वक बनती हैं, यानी वे कारें जिनके उत्पादन में कोई एरर नहीं होती।
एक फंक्शन बनाइए जो प्रति घंटे बनने वाली कारों की संख्या और सफलता दर लेता है और निकालता है कि प्रति घंटे कितनी कारें सफलतापूर्वक बनती हैं।
सफलता दर प्रतिशत में दी जाती है, 0 से 100 तक:
CalculateWorkingCarsPerHour(1547, 90)
// => 1392.3
ध्यान दें: रिटर्न वैल्यू float64 होनी चाहिए।
2. प्रति मिनट बनने वाली काम करने वाली कारों की संख्या निकालिए
एक फंक्शन बनाइए जो प्रति घंटे बनने वाली कारों की संख्या और सफलता दर लेता है और निकालता है कि हर मिनट कितनी कारें सफलतापूर्वक बनती हैं:
CalculateWorkingCarsPerMinute(1105, 90)
// => 16
ध्यान दें: रिटर्न वैल्यू int होनी चाहिए।
3. उत्पादन की लागत निकालिए
आम तौर पर हर कार को अलग-अलग बनाने में $10,000 की लागत आती है, चाहे वह सफल हो या न हो।
लेकिन थोड़ी योजना बनाकर 10 कारें एक साथ $95,000 में बनाई जा सकती हैं।
उदाहरण के लिए, 37 कारें इस तरह बनाई जा सकती हैं:
37 = दस के 3 समूह + 7 अलग-अलग कारें
तो 37 कारों की लागत है:
3*95,000+7*10,000=355,000
CalculateCost फंक्शन बनाइए, जो कई कारों को बनाने की लागत निकालता है, चाहे वे सफल हों या न हों:
CalculateCost(37)
// => 355000
CalculateCost(21)
// => 200000
ध्यान दें: रिटर्न वैल्यू uint होनी चाहिए।
सीखने का अभ्यास
