विषय - सूची
मैं टार्जन के छद्मकोश की अपनी व्याख्या को निम्नलिखित खंडों में विभाजित करूंगा :
- टारजन के इफ-ब्लॉक (
->और |ऑपरेटर)
- असाइनमेंट और इक्विटी टेस्ट (
:=और =)
- वहाँ है
else if, लेकिन कोई elseनिर्माण नहीं है
- टारजन कंडिशनल असाइनमेंट ऑपरेटर
:= if
टार्जन केif:= if
5.5 और 5.5 के अतिरिक्त उदाहरण ।
टारजन एरे (या सूची)
संचालकों का सारांश
- टारजन का डबल-पॉइंट एरो ऑपरेटर (
⟷)
- टारजन के डू-लूप, सी / जावा की तरह होते हैं, जबकि लूप
- सभी झूठी शर्तों के साथ टार्जन के सशर्त-असाइनमेंट ऑपरेटर
(१) टारजन की इफ-ब्लॉक
(ऑपरेटर →और |)
if-elseनिर्माण शायद Tarjan की भाषा में सबसे मौलिक नियंत्रण संरचना है। C-like if-block के अलावा, if-else व्यवहार बहुत ही अंतर्निहित टार्जन के असाइनमेंट्स में है और टारजन के लूप्स। टारजन के तीर ऑपरेटर ->(या →) एक इफ-स्टेटम की स्थिति और एक इफ-स्टेटमेंट के निष्पादन ब्लॉक के बीच एक सीमांकक है।
उदाहरण के लिए, टारजन की भाषा में हम हो सकते हैं:
# Example One
if a = 4 → x := 9 fi
यदि हम टार्जन कोड की लाइन को C या Java में आंशिक रूप से अनुवादित करते हैं, तो हमें निम्नलिखित मिलते हैं:
if (a = 4)
x := 9
fi
एक सही घुंघराले ब्रेसिज़ की तरह (सी और जावा में) के रूप में ifटारजन एक ALGOL जैसे बैकवर्ड की-वर्ड की स्पेलिंग के साथ एक-एंड को समाप्त करता है:fi
यदि हम अपने उपरोक्त उदाहरण का अनुवाद जारी रखते हैं, तो हमें यह मिलता है:
if (a = 4) {
x := 9
}
(2) असाइनमेंट और इक्विटी टेस्ट ( :=और =)
टारजन इन ऑपरेटरों को ALGOL (बाद में पास्कल में भी देखा जाता है) से लेता है।
टारजन =समानता परीक्षणों के लिए उपयोग करता है , असाइनमेंट्स में नहीं (इसलिए यह जावा की तरह काम करता है ==)।
असाइनमेंट के लिए, टारजन उपयोग करता है :=, जो जावा की तरह काम करता है =।
इस प्रकार, यदि हम अपने उदाहरण का अनुवाद जारी रखते हैं, तो हमारे पास है:
if (a == 4) {
x = 9
}
|टारजन की भाषा में एक ऊर्ध्वाधर पट्टी (या "पाइप" या ) else ifसी या जावा में कीवर्ड के बराबर है ।
उदाहरण के लिए, टारजन की भाषा में हम हो सकते हैं:
# Example Two
if a = 4 → x := 9 | a > 4 → y := 11 fi
ऊपर दिया गया टारजन-कोड:
if (a == 4) {
x = 9
}
else if (a > 4) {
y = 11
}
(३) else ifकेवल और कोई elseनिर्माण नहीं
इससे पहले, मैंने ifबारीकियों का वर्णन किए बिना बुनियादी बातों को कवर किया । हालांकि, हम एक छोटे से विस्तार पर चर्चा नहीं करेंगे। टार्जन-इयान if-elseब्लॉक में अंतिम क्लॉज में हमेशा एक तीर ( →) ऑपरेटर होना चाहिए । जैसे, elseटारजन की भाषा में कोई नहीं है, केवल else if। elseटार्जन की भाषा में -ब्लॉक करने के लिए निकटतम चीज सबसे सही परीक्षण-स्थिति बनाना है true।
if a = 4 → x := 9 | a > 4 → y := 11 | true → z := 99 fi
C / Java में, हमारे पास होगा:
if (a == 4) {
x = 9
}
else if (a > 4) {
y = 11
}
else { // else if (true)
z = 99
}
सामान्य विवरणों की तुलना में उदाहरण समझना आसान है। हालाँकि, अब हमारे पास कुछ उदाहरण हैं जो हमारे बेल्ट के तहत हैं, जानते हैं कि एक टारजन की अगर-और निर्माण की सामान्य औपचारिकता इस प्रकार है:
if condition
→ stuff to do
| condition
→ stuff to do
[...]
| condition
→ stuff to do
fi
चरित्र |जैसा हैif else
चरित्र →परीक्षण-स्थिति को सामान-से-अलग करता है।
(४) टारजन का सशर्त संचालक संचालक := if
टारजन का ifउपयोग दो अलग-अलग तरीकों से किया जा सकता है। अब तक, हमने केवल तर्जान के उपयोगों में से एक का वर्णन किया है if। कुछ भ्रम की स्थिति में, टारजन अभी भी ifदूसरे प्रकार के if-कनॉस्ट्रक्शन के लिए संकेतन / वाक्यविन्यास का उपयोग करता है । जिसका ifउपयोग किया जा रहा है वह संदर्भ पर आधारित है। संदर्भ का विश्लेषण करना वास्तव में बहुत आसान है क्योंकि दूसरे प्रकार के टारजन- ifहमेशा एक असाइनमेंट ऑपरेटर द्वारा पूर्व-निर्धारित होते हैं।
उदाहरण के लिए, हमारे पास निम्नलिखित टार्जन कोड हो सकते हैं:
# Example Three
x := if a = 4 → 9 fi
पाचन शुरू करें
थोड़ी देर के लिए टारजन कोड के साथ काम करने के बाद, आपको ऑपरेशन के आदेश की आदत हो जाती है। यदि हम उपरोक्त उदाहरण में परीक्षण की स्थिति को छोटा करते हैं, तो हम प्राप्त करते हैं:
x := if (a = 4) → 9 fi
a = 4असाइनमेंट ऑपरेशन नहीं है। a = 4यह पसंद है a == 4- यह सही या गलत है।
अंत पाचन
यह := ifएकल ऑपरेटर के लिए वाक्यविन्यास के रूप में सोचने में मदद कर सकता है , इससे अलग :=और ifवास्तव में, हम := ifऑपरेटर को "सशर्त असाइनमेंट" ऑपरेटर के रूप में संदर्भित करेंगे।
के लिए ifहम सूची (condition → action)। के लिए := ifहम सूची (condition → value)जहां valueतेह दाएँ हाथ की ओर मूल्य हम बाएं हाथ की ओर करने के लिए निर्धारित करना चाहेंगे हैlhs
# Tarjan Example Four
lhs := if (a = 4) → rhs fi
सी या जावा में लग सकता है:
# Example Four
if (a == 4) {
lhs = rhs
}
टार्जनियन कोड में "सशर्त असाइनमेंट" के निम्नलिखित उदाहरण पर विचार करें:
# उदाहरण पांच का टार्जन इंस्टेंटेशन: = a = ४ → ९ | a> 4 → 11 | सच → 99 फाई
C / Java में, हमारे पास होगा:
// C/Java Instantiation of Example Five
if (a == 4) {
x = 9
}
else if (a > 4) {
x = 11
}
else if (true) { // else
x = 99
}
(5) ऑपरेटरों का सारांश:
अब तक, हमारे पास:
:=...... असाइनमेंट ऑपरेटर (C / Java =)
=...... समानता परीक्षण (C / Java ==)
→ ...... एक-ब्लॉक के परीक्षण-स्थिति और अगर-ब्लॉक के शरीर के बीच परिसीमन
| ..... सी / जावा और-यदि
if ... fi ..... अगर-और ब्लॉक
:= if... fi ..... एक और ब्लॉक पर आधारित सशर्त असाइनमेंट
(५.५) टारजन लिस्ट्स / एरेस:
टारजन की भाषा में बिल्ट-इन सरणी जैसे कंटेनर हैं। टारजन सरणियों के लिए वाक्य विन्यास टार्जन if elseस्टेटमेंट के लिए संकेतन की तुलना में बहुत अधिक सहज है ।
list1 := ['lion', 'witch', 'wardrobe'];
list2a := [1, 2, 3, 4, 5];
list2b := [1, 2];
list3 := ["a", "b", "c", "d"];
list4 := [ ]; # an empty array
टारजन सरणी तत्व कोष्ठक के साथ एक्सेस किया जाता है (), न कि चौकोर कोष्ठक के साथ[]
अनुक्रमण शुरू होता है 1। इस प्रकार,
list3 := ["a", "b", "c", "d"]
# list3(1) == "a" returns true
# list3(2) == "b" return true
नीचे दिखाया गया है कि 1 और 5 के तत्वों से युक्त एक नया सरणी कैसे बनाएं [1, 2, 3, 4, 5, 6, 7]
nums := [1, 2, 3, 4, 5, 6, 7]
new_arr := [nums(1), nums(5)]
समानता ऑपरेटर को सरणियों के लिए परिभाषित किया गया है। निम्नलिखित कोड प्रिंट करता हैtrue
x := false
if [1, 2] = [1, 2, 3, 4, 5] --> x := true
print(x)
किसी सारणी के खाली होने पर टार्जन का तरीका यह है कि इसकी तुलना एक खाली सरणी से की जाए
arr := [1, 2]
print(arr = [ ])
# `=` is equality test, not assignment
()संयुक्त के साथ ऑपरेटर को कई सूचकांक प्रदान करके, एक उप-सरणी का एक दृश्य (कॉपी नहीं) बना सकता है..
list3 := ["a", "b", "c", "d"]
beg := list3(.. 2)
# beg == ["a", "b"]
# beg(1) == "a"
end := list3(3..)
# end == ["c", "d"]
# end(1) == "c"
mid := list3(2..3)
# mid == ["b", "c"]
# mid(2) == "c"
# `list3(4)` is valid, but `mid(4)` is not
(6) Tarjan के के अतिरिक्त उदाहरण ifऔर:= if
निम्नलिखित एक टार्जन सशर्त असाइनमेंट ( := if) का एक और उदाहरण है :
# Tarjan Example Six
a := (false --> a | true --> b | false --> c1 + c2 | (2 + 3 < 99) --> d)
(true --> b)(cond --> action)एक वास्तविक स्थिति वाले सबसे बाएं खंड है। इस प्रकार, मूल असाइनमेंट उदाहरण सिक्स में समान असाइनमेंट-व्यवहार हैa := b
नीचे टार्जन कोड का हमारा सबसे जटिल उदाहरण इस प्रकार है:
# Tarjan Example -- merge two sorted lists
list function merge (list s, t);
return if s =[] --> t
| t = [ ] --> s
| s != [ ] and t != [] and s(l) <= t(1) -->
[s(1)]& merge(s[2..], t)
| s != [ ]and t != [ ] and s(1) > r(l) -->
[t(1)] & merge (s,t(2..))
fi
end merge;
दो क्रमबद्ध सूचियों के विलय के लिए टारजन कोड का अनुवाद निम्नलिखित है। निम्नलिखित बिल्कुल सी या जावा नहीं है, लेकिन यह टार्जन संस्करण की तुलना में सी / जावा के बहुत करीब है।
list merge (list s, list t) {
if (s is empty) {
return t;
}
else if (t is empty){
return s;
}
else if (s[1] <= t[1]) {
return CONCATENATE([s[1]], merge(s[2...], t));
else { // else if (s[1] > t[1])
return CONCATENATE ([t[1]], merge(s,t[2..]);
}
}
नीचे अभी तक टार्जन-कोड का एक और उदाहरण और सी या जावा के समान अनुवाद है:
heap function meld (heap h1, h2);
return if h1 = null --> h2
| h2 = null --> h1
| h1 not null and h2 not null --> mesh (h1, h2)
fi
end meld;
नीचे C / Java अनुवाद है:
HeapNode meld (HeapNode h1, HeapNode h2) {
if (h1 == null) {
return h2;
}
else if (h2 == null) {
return h1;
} else {
mesh(h1, h2)
}
} // end function
(() टारजन का डबल-पॉइंट एरो ऑपरेटर ( <-->)
नीचे टार्जन कोड का एक उदाहरण है:
x <--> y
⟷टारजन की भाषा में एक डबल एरो ( ) ऑपरेटर क्या करता है ?
खैर, टारजन की भाषा में लगभग सभी चर पॉइंटर्स हैं।
<-->एक स्वैप ऑपरेशन है। निम्नलिखित प्रिंटtrue
x_old := x
y_old := y
x <--> y
print(x == y_old) # prints true
print(y == x_old) # prints true
प्रदर्शन करने के बाद x <--> y, xउस वस्तु की yओर इशारा करता है जो उस वस्तु की ओर इशारा करती है और yउस वस्तु की xओर इशारा करती है, जो इंगित करती थी।
नीचे <-->ऑपरेटर का उपयोग कर एक टार्जन स्टेटमेंट दिया गया है:
x := [1, 2, 3]
y := [4, 5, 6]
x <--> y
नीचे वैकल्पिक छद्मकोड के ऊपर टार्जन कोड से एक अनुवाद है:
Pointer X = address of array [1, 2, 3];
Pointer Y = address of array [4, 5, 6];
Pointer X_OLD = address of whatever X points to;
X = address of whatever Y points to;
Y = address of whatever X_OLD points to;
वैकल्पिक रूप से, हम कर सकते हैं:
void operator_double_arrow(Array** lhs, Array** rhs) {
// swap lhs and rhs
int** old_lhs = 0;
old_lhs = lhs;
*lhs = *rhs;
*rhs = *old_lhs;
return;
}
int main() {
Array* lhs = new Array<int>(1, 2, 3);
Array* rhs = new Array<int>(4, 5, 6);
operator_double_arrow(&lhs, &rhs);
delete lhs;
delete rhs;
return 0;
}
नीचे ⟷ऑपरेटर के उपयोग से टार्जन के कार्यों में से एक का एक उदाहरण है :
heap function mesh (heap nodes h1, h2);
if key(h1) > key(h2) → h1 ⟷ h2 fi;
right (h1) := if right(h1) = null → h2
|right(h1) ≠ null → mesh (right(h1), h2)
fi;
if rank (left (h1)) < rank (right (h1))
→ left(h1) ⟷ right(h1)
fi;
rank (h1) := rank(right(h1)) + 1;
return h1;
end mesh;
नीचे टारजन के meshफ़ंक्शन का छद्म कोड में अनुवाद है जो सी नहीं है, लेकिन सी (अपेक्षाकृत बोलने वाला) की तरह दिखता है। इसका उद्देश्य यह बताना है कि टारजन के ⟷ऑपरेटर कैसे काम करते हैं।
node pointer function mesh(node pointers h1, h2) {
if (h1.key) > h2.key) {
// swap h1 and h2
node pointer temp;
temp = h1;
h1 = h2;
h2 = temp;
}
// Now, h2.key <= h1.key
if (h1.right == null) {
h1.right = h2;
} else // h1.key != null {
h1.right = mesh(h1.right, h2);
}
if (h1.left.rank < h1.right.rank ) {
// swap h1.left and h1.right
node pointer temp;
temp = h1;
h1 = h2;
h2 = temp;
}
h1.rank = h1.right.rank + 1;
return h1;
}
(() टारजन के डू-लूप, लूप के सी / जावा की तरह होते हैं
टारजन की भाषा ifऔर forनिर्माण सी / जावा प्रोग्रामर के लिए परिचित हैं। हालाँकि, टारजन कीवर्ड थोड़ी देर के लिए है do। All do-loops कीवर्ड के साथ समाप्त होता है od, जो कि पीछे की ओर वर्तनी है do। नीचे एक उदाहरण है:
sum := 0
do sum < 50 → sum := sum + 1
सी-स्टाइल छद्मकोड में, हमारे पास:
sum = 0;
while(sum < 50) {
sum = sum + 1;
}
उपरोक्त वास्तव में काफी सही नहीं है। एक टारजन डो-लूप वास्तव में एक सी / जावा है while(true)जिसके अंदर एक और ब्लॉक नेस्टेड है। टारजन कोड का एक अधिक शाब्दिक अनुवाद इस प्रकार है:
sum = 0;
while(true) {
if (sum < 50) {
sum = sum + 1;
continue;
// This `continue` statement is questionable
}
break;
}
नीचे, हमारे पास एक अधिक जटिल टारजन- doलूप है:
sum := 0
do sum < 50 → sum := sum + 1 | sum < 99 → sum := sum + 5
जटिल टार्जन- doलूप के लिए सी / जावा-शैली छद्मकोड निम्नानुसार है:
sum = 0;
while(true) {
if (sum < 50) {
sum = sum + 1;
continue;
}
else if (sum < 99) {
sum = sum + 5;
continue;
}
break;
}
(9) टार्जन के कंडिशनल-असाइनमेंट ऑपरेटर सभी झूठी शर्तों के साथ
हालाँकि ऊपर दी गई लम्बी व्याख्या में अधिकांश बातें शामिल हैं, लेकिन कुछ मामले अभी भी अनसुलझे हैं। मुझे उम्मीद है कि किसी और दिन मेरा एक नया-बेहतर जवाब होगा जो खदान के आधार पर लिखा जाएगा।
विशेष रूप से, जब सशर्त असाइनमेंट ऑपरेटर := ifका उपयोग किया जाता है, और कोई भी शर्त सच नहीं होती है, तो मैं वह नहीं हूं जो चर के लिए सौंपा गया है।
x := if (False --> 1| False --> 2 | (99 < 2) --> 3) fi
मुझे यकीन नहीं है, लेकिन यह संभव है कि कोई काम नहीं किया जाता है x:
x = 0;
if (false) {
x = 1;
}
else if (false) {
x = 2;
}
else if (99 < 2) {
x = 3;
}
// At this point (x == 0)
आप की आवश्यकता हो सकती है कि एक := ifबयान में देखा गया बाएं हाथ की ओर वाला चर पहले घोषित किया गया हो। उस स्थिति में, भले ही सभी स्थितियां झूठी हों, चर का अभी भी एक मूल्य होगा।
वैकल्पिक रूप से, शायद सभी-झूठी स्थितियां एक रनटाइम त्रुटि का प्रतिनिधित्व करती हैं। एक अन्य विकल्प एक विशेष nullमूल्य वापस करना है , और nullअसाइनमेंट के बाएं हाथ के तर्क में स्टोर करना है।