Added Hindi amd (#1673)

* Added Hindi amd.html.maarkdown

* Added D.html.markdown

* removed

* Added D.html.markdown

* Fixing..

* Added D.html.markup finally

1 files changed, 256 insertions, 0 deletions

diff --git a/hd-hd/d.html.markdown b/hd-hd/d.html.markdown
new file mode 100644
index 00000000..80cf3bed
--- /dev/null
+++ b/hd-hd/d.html.markdown
@@ -0,0 +1,256 @@
+---
+language: D
+filename: learnd.d
+contributors:
+    - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
+lang: en
+---
+
+```c
+//क्या आ रहा है पता है ...
+module hello;
+
+import std.stdio;
+
+void main(string[] args) {
+    writeln("Hello, World!");
+}
+```
+
+अगर आप मेरे जैसे हैं और इंटरनेट पर समय बहुत अधिक समय खर्च करते हैं, तो आप बाधाओं के बारे में सुना है
+के बारे में [डी ] ( http://dlang.org/ )। डी प्रोग्रामिंग भाषा में एक आधुनिक, सामान्य प्रयोजन है ,
+सब कुछ के लिए समर्थन कम स्तर की सुविधाओं से करने के साथ बहु - प्रतिमान भाषा
+अर्थपूर्ण उच्च स्तरीय चीजें ।
+
+D सक्रिय रूप से सुपर स्मार्ट लोगों का एक बड़ा समूह द्वारा विकसित की है और नेतृत्व द्वारा किया जाता है
+[ वाल्टर ब्राइट ] ( https://en.wikipedia.org/wiki/Walter_Bright ) और
+[ आंद्रेई Alexandrescu ] ( https://en.wikipedia.org/wiki/Andrei_Alexandrescu )।
+जिस तरह की है कि सभी के साथ बाहर, चलो कुछ उदाहरणों पर गौर करते हैं!
+
+
+```c
+import std.stdio;
+
+void main() {
+
+    for(int i = 0; i < 10000; i++) {
+        writeln(i);
+    }
+
+    // 'auto' can be used for inferring types.
+    auto n = 1;
+
+    // संख्यात्मक literals स्पष्टता के लिए एक अंकों विभाजक के रूप में '_' का उपयोग कर सकते हैं।
+    while(n < 10_000) {
+        n += n;
+    }
+
+    do {
+        n -= (n / 2);
+    } while(n > 0);
+    // लिए और जब तक अच्छा कर रहे हैं, लेकिन D में हम 'foreach' छोरों पसंद करते हैं।
+    // '..' पहला मान सहित एक सतत श्रृंखला बनाता है,
+    // लेकिन पिछले छोड़कर।
+    foreach(i; 1..1_000_000) {
+        if(n % 2 == 0)
+            writeln(i);
+    }
+
+    // वहाँ भी 'foreach_reverse' आप पीछे की ओर पाश करना चाहते हैं।
+    foreach_reverse(i; 1..int.max) {
+        if(n % 2 == 1) {
+            writeln(i);
+        } else {
+            writeln("No!");
+        }
+    }
+}
+```
+
+हम ' struct`, `class`,` union`, और `` enum` साथ नए प्रकार परिभाषित कर सकते हैं। Structs और unions
+मूल्य से कार्य करने के लिए पारित कर रहे हैं (यानी नकल) और वर्गों के संदर्भ द्वारा पारित कर रहे हैं। इसके अलावा,
+हम प्रकारों और मानों दोनों पर करने के लिए टेम्पलेट का उपयोग कर सकते हैं!
+
+```c
+// इधर, 'T' एक प्रकार पैरामीटर है। लगता है कि '&lt;+T&gt;' C++ / C/ Java से।
+struct LinkedList(T) {
+    T data = null;
+
+    // '!'का प्रयोग करें , एक पैरामिट्रीकृत प्रकार इन्स्तांत । फिर, '<T >' लगता है।
+    LinkedList!(T)* next;
+}
+
+class BinTree(T) {
+    T data = null;
+
+// केवल एक टेम्पलेट पैरामीटर नहीं है, तो  , हम कोष्ठकों छोड़ सकते हैं।
+    BinTree!T left;
+    BinTree!T right;
+}
+
+enum Day {
+    Sunday,
+    Monday,
+    Tuesday,
+    Wednesday,
+    Thursday,
+    Friday,
+    Saturday,
+}
+
+// उपयोग उर्फ प्रकार (alias) के लिए संक्षिप्त बनाने के लिए।
+alias IntList = LinkedList!int;
+alias NumTree = BinTree!double;
+
+//हम के रूप में अच्छी तरह से कार्य टेम्पलेट्स बना सकते हैं!
+T max(T)(T a, T b) {
+    if(a < b)
+        return b;
+
+    return a;
+}
+
+// संदर्भ द्वारा पारित सुनिश्चित करने के लिए रेफरी कीवर्ड का प्रयोग करें । यही कारण है कि यहां तक ​​कि 'A' और 'B' , तो है
+//मान प्रकार वे हमेशा ' swap()' के संदर्भ द्वारा पारित हो जाएगा  हैं ।
+void swap(T)(ref T a, ref T b) {
+    auto temp = a;
+
+    a = b;
+    b = temp;
+}
+
+// टेम्पलेट्स के साथ, हम भी मूल्यों पर परमेटेराइज़  कर सकते हैं , न सिर्फ types.With टेम्पलेट्स, हम भी नहीं है, बस प्रकार , मूल्यों पर parameterize कर सकते हैं।
+class Matrix(uint m, uint n, T = int) {
+    T[m] rows;
+    T[n] columns;
+}
+
+auto mat = new Matrix!(3, 3);
+
+```
+
+Classes की बात हो रही है , एक दूसरे के लिए गुणों के बारे में बात करते हैं। एक संपत्ति
+एक value की तरह कार्य कर सकते हैं कि एक समारोह में मोटे तौर पर है, इसलिए हम कर सकते हैं
+के शब्दों के साथ पॉड संरचनाओं की वाक्य रचना (` structure.x = 7` ) है
+मनुष्य और सेटर तरीकों ( ` object.setX (7) `) !
+
+```c
+// Consider a class parameterized on types 'T' & 'U'.
+class MyClass(T, U) {
+    T _data;
+    U _other;
+}
+
+// And "getter" and "setter" methods like so:
+class MyClass(T, U) {
+    T _data;
+    U _other;
+
+    // भवन निर्माताओं हमेशा नामित कर रहे हैं 'this'.
+    this(T t, U u) {
+        //यह नीचे सेटर तरीकों से मुलाकात करेंगे।
+        data = t;
+        other = u;
+    }
+
+    // getters
+    @property T data() {
+        return _data;
+    }
+
+    @property U other() {
+        return _other;
+    }
+
+    // setters
+    @property void data(T t) {
+        _data = t;
+    }
+
+    @property void other(U u) {
+        _other = u;
+    }
+}
+
+//और हम इस तरह से उन का उपयोग करें :
+void main() {
+    auto mc = new MyClass!(int, string)(7, "seven");
+
+   करने के लिए लिखने के लिए मानक पुस्तकालय से
+   // आयात ' stdio ' मॉड्यूल
+    // सांत्वना (आयात एक गुंजाइश के लिए स्थानीय हो सकता है) ।
+    import std.stdio;
+
+    // Call the getters to fetch the values.
+    writefln("Earlier: data = %d, str = %s", mc.data, mc.other);
+
+    // Call the setters to assign new values.
+    mc.data = 8;
+    mc.other = "eight";
+
+    // Call the getters again to fetch the new values.
+    writefln("Later: data = %d, str = %s", mc.data, mc.other);
+}
+```
+
+गुणों के साथ, हम तर्क की किसी भी राशि को जोड़ सकते हैं
+हमारे मनुष्य और सेटर तरीकों, और की साफ वाक्य रचना रखना
+सीधे सदस्यों तक पहुँचने !
+
+हमारे निपटान पर अन्य वस्तु उन्मुख उपहार
+` interface`s , ` सार class`es शामिल
+और ` तरीकों override`ing । डी सिर्फ जावा की तरह विरासत करता है:
+आप कृपया के रूप में कई इंटरफेस को लागू करने, एक वर्ग का विस्तार ।
+
+हम डी एस OOP सुविधाओं देखा , लेकिन स्विच गियर छोड़ दिया । डी प्रस्तावों
+प्रथम श्रेणी के कार्यों के साथ कार्यात्मक प्रोग्रामिंग, ` pure`
+काम करता है, और अपरिवर्तनीय डेटा । इसके अलावा, अपने पसंदीदा के सभी
+कार्यात्मक एल्गोरिदम ( नक्शा, फिल्टर , कम करने और मित्र हो सकते हैं)
+अद्भुत ` std.algorithm` मॉड्यूल में पाया!
+
+```c
+import std.algorithm : map, filter, reduce;
+import std.range : iota; // builds an end-exclusive range
+
+void main() {
+    // हम भी ints के वर्गों की एक सूची का योग मुद्रित करना चाहते हैं
+    // 1 से 100 के लिए आसान करने के लिए!
+
+    // बस टेम्पलेट पैरामीटर के रूप में लैम्ब्डा भाव के पास!
+    // आप आप की तरह किसी भी पुराने समारोह पारित कर सकते हैं , लेकिन lambdas यहाँ सुविधाजनक हैं।
+    auto num = iota(1, 101).filter!(x => x % 2 == 0)
+                           .map!(y => y ^^ 2)
+                           .reduce!((a, b) => a + b);
+
+    writeln(num);
+}
+```
+
+हम NUM गणना करने के लिए एक अच्छा Haskellian पाइपलाइन का निर्माण करने के लिए मिला सूचना कैसे ?
+यही कारण है कि एक डी नवाचार करने के लिए धन्यवाद वर्दी समारोह कॉल सिंटेक्स के रूप में जानते हैं।
+UFCS के साथ, हम एक विधि के रूप में एक समारोह कॉल लिखने के लिए चुन सकते हैं
+या मुफ्त समारोह कॉल ! वाल्टर इस पर एक अच्छा लेख लिखा था
+[यहाँ ।] ( http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394 )
+संक्षेप में, आप जिनकी पहली पैरामीटर कार्यों कॉल कर सकते हैं
+एक विधि के रूप में ग्रुप ए की किसी भी अभिव्यक्ति पर कुछ प्रकार एक की है ।
+
+मैं समानता चाहते । समानता की तरह कोई और? ज़रूर तुम करना। चलो कुछ करते हैं!
+```c
+import std.stdio;
+import std.parallelism : parallel;
+import std.math : sqrt;
+
+void main() {
+ // हम हमारे सरणी में वर्गमूल हर नंबर ले जाना चाहता हूँ ,
+ // हम उपलब्ध है के रूप में और के रूप में कई कोर का लाभ ले।
+    auto arr = new double[1_000_000];
+
+   // संदर्भ के द्वारा एक सूचकांक , और एक सरणी तत्व का प्रयोग
+    // और सिर्फ सरणी पर समानांतर फोन!
+    foreach(i, ref elem; parallel(arr)) {
+        ref = sqrt(i + 1.0);
+    }
+}
+
+
+```