दिलचस्प पोस्ट
कैसे जीडीबी में किसी दिए गए पते पर विधानसभा निर्देश को तोड़ने के लिए? (माइ) एसक्यूएल इंजेक्शन को रोकने के लिए कौन-से पात्रों को बचाना है? कैसे सी + + संदर्भ देखो, स्मृति-वार? क्या किसी को विज़ुअल स्टूडियो 6 के साथ विंडोज 7 पर सफलता मिली है? एचटीएमएलआई सत्यापन जब इनपुट प्रकार "जमा" नहीं होता है LINQ के माध्यम से संग्रह के सभी तत्वों पर फ़ंक्शन लागू करें iPhone ऐप स्थानीयकरण – अंग्रेजी समस्याएं? CakePHP में base_url कई विशेषताओं द्वारा एक सूची को सॉर्ट करें? मैं किसी स्वरूपित प्रारूप में बिना किसी प्रारूप के दूसरे दिनांक में दूसरे प्रारूप में तिथि कैसे बदल सकता हूँ? JQuery के लिए अनुशंसित JavaScript HTML टेम्पलेट लाइब्रेरी? कई उदाहरणों के लिए jQuery की तारीख पिकर लागू करें PHP में 500MB से ऊपर बड़ी फ़ाइलों को कैसे अपलोड करें आप जावास्क्रिप्ट में 1 दशमलव स्थान पर कैसे गोल करते हैं? numpy: "array_like" वस्तुओं की औपचारिक परिभाषा?

अस्थायी चर का उपयोग किए बिना दो चर को स्वैप करें

मैं सी # में एक अस्थायी चर के उपयोग के बिना दो चर स्वैप करने में सक्षम होना चाहता हूँ क्या यह किया जा सकता है?

decimal startAngle = Convert.ToDecimal(159.9); decimal stopAngle = Convert.ToDecimal(355.87); // Swap each: // startAngle becomes: 355.87 // stopAngle becomes: 159.9 

Solutions Collecting From Web of "अस्थायी चर का उपयोग किए बिना दो चर को स्वैप करें"

सबसे पहले, किसी भाषा में अस्थायी चर के बिना गमागमन सी # के रूप में बहुत बुरा विचार है

लेकिन उत्तर के लिए, आप इस कोड का उपयोग कर सकते हैं:

 startAngle = startAngle + stopAngle; stopAngle = startAngle - stopAngle; startAngle = startAngle - stopAngle; 

हालाँकि समस्याएं घूमती रहती हैं, यदि दोनों संख्या काफी हद तक भिन्न होती हैं यह चल बिन्दु संख्याओं की प्रकृति के कारण है।

यदि आप अस्थायी चर को छुपाना चाहते हैं, तो आप उपयोगिता विधि का उपयोग कर सकते हैं:

 public static class Foo { public static void Swap<T> (ref T lhs, ref T rhs) { T temp = lhs; lhs = rhs; rhs = temp; } } 

दो चर को स्वैप करने का सही तरीका यह है:

 decimal tempDecimal = startAngle; startAngle = stopAngle; stopAngle = tempDecimal; 

दूसरे शब्दों में, एक अस्थायी चर का उपयोग करें

ये लो। कोई चालाक चालें नहीं, आपके कोड के कोई भी संरक्षक आपको आने वाले दशकों तक दिक्कत नहीं कर रहे हैं, दैनिक डब्ल्यूटीएफ के लिए कोई प्रविष्टि नहीं है, और यह समझने की कोशिश करने में बहुत अधिक समय व्यतीत नहीं है कि किसी भी आपरेशन में इसकी आवश्यकता क्यों है, वैसे भी निम्नतम स्तर पर सबसे जटिल भाषा की सुविधा सरल ऑपरेशन की एक श्रृंखला है।

बस एक बहुत ही सरल, पठनीय, समझने में आसान, t = a; a = b; b = t; t = a; a = b; b = t; उपाय।

मेरी राय में, डेवलपर्स, जो कि ट्रिक्स का उपयोग करने की कोशिश करते हैं, उदाहरण के लिए, "एक अस्थायी उपयोग किए बिना स्वैप वैरिएबल" या "डफ़ की डिवाइस" केवल यह दिखाते हैं कि वे कितने चतुर हैं (और बुरी तरह विफल)।

मैं उन लोगों की तुलना उन लोगों के लिए करता हूं जो पार्टियों पर और अधिक दिलचस्प लगने के उद्देश्य से उच्च स्क्रू किताबें पढ़ते हैं (जैसा कि आपके क्षितिज का विस्तार करने का विरोध)।

जिन समाधानों को आप जोड़ते हैं और घटाते हैं, या XOR- आधारित होते हैं, वे साधारण "temp variable" समाधान (विधानसभा स्तर पर सादा चाल के बजाय अंकगणित / बूलीयन-ऑप्स) की तुलना में कम पठनीय और धीमी गति से होते हैं।

अच्छी गुणवत्ता वाले पढ़ने योग्य कोड लिखकर स्वयं और दूसरों को एक सेवा दें

यह मेरा शेख़ी है सुनने के लिए धन्यवाद 🙂

एक तरफ, मुझे पता चल गया है कि यह आपके विशिष्ट प्रश्न का उत्तर नहीं देता (और मैं इसके लिए माफी मांगूंगा) पर SO पर बहुत सारे उदाहरण हैं, जहां लोगों ने पूछा है कि कैसे कुछ करना है और सही उत्तर है "नहीं कर दो"।

हां, इस कोड का उपयोग करें:

 stopAngle = Convert.ToDecimal(159.9); startAngle = Convert.ToDecimal(355.87); 

समस्या मनमाना मूल्यों के लिए कठिन है 🙂

 int a = 4, b = 6; a ^= b ^= a ^= b; 

तारों और फ़्लोट्स सहित सभी प्रकार के लिए काम करता है

बेनएलाबेस्टर ने एक परिवर्तनीय स्विच करने का एक व्यावहारिक तरीका दिखाया, लेकिन कोशिश-पकड़ वाले खंड की आवश्यकता नहीं है। यह कोड पर्याप्त है

 static void Swap<T>(ref T x, ref T y) { T t = y; y = x; x = t; } 

उपयोग वह जैसा ही दिखाया गया है:

 float startAngle = 159.9F float stopAngle = 355.87F Swap(ref startAngle, ref stopAngle); 

आप एक एक्सटेंशन विधि का भी उपयोग कर सकते हैं:

 static class SwapExtension { public static T Swap<T>(this T x, ref T y) { T t = y; y = x; return t; } } 

इसे इस तरह प्रयोग करें:

 float startAngle = 159.9F; float stopAngle = 355.87F; startAngle = startAngle.Swap(ref stopAngle); 

दोनों तरीकों से विधि में एक अस्थायी चर का उपयोग होता है, लेकिन आपको अस्थायी चर की आवश्यकता नहीं है जहां आप गमागमन करते हैं

विस्तृत उदाहरण के साथ एक द्विआधारी XOR स्वैप:

XOR सत्य तालिका :

 aba^b 0 0 0 0 1 1 1 0 1 1 1 0 

इनपुट:

 a = 4; b = 6; 

चरण 1 : ए = एक ^ बी

 a : 0100 b : 0110 a^b: 0010 = 2 = a 

चरण 2 : बी = एक ^ बी

 a : 0010 b : 0110 a^b: 0100 = 4 = b 

चरण 3 : ए = एक ^ बी

 a : 0010 b : 0100 a^b: 0110 = 6 = a 

आउटपुट:

 a = 6; b = 4; 

सी # 7 एक उचित Tuples परिचय Tuples जो अस्थायी एक के बिना दो चर गमागमन को सक्षम करता है:

 int a = 10; int b = 2; (a, b) = (b, a); 

यह b को a और a को b को नियत करता है।

सी में नहीं # मूल कोड में आप ट्रिपल-एक्सओआर स्वैप चाल का उपयोग कर सकते हैं, लेकिन उच्च स्तर के प्रकार-सुरक्षित भाषा में नहीं। (वैसे भी, मैंने सुना है कि XOR ट्रिक वास्तव में बहुत सी आम सीपीयू आर्किटेक्चर में एक अस्थायी चर का उपयोग करने से धीमी गति से समाप्त होता है।)

आपको एक अस्थायी चर का उपयोग करना चाहिए कोई कारण नहीं है कि आप एक का उपयोग नहीं कर सकते हैं; ऐसा नहीं है कि सीमित आपूर्ति है

भविष्य के शिक्षार्थियों और मानवता के लिए, मैं इस सुधार को वर्तमान में चयनित उत्तर में प्रस्तुत करता हूं।

यदि आप अस्थायी चर का उपयोग करने से बचना चाहते हैं, तो केवल दो सही विकल्प हैं जो पहले प्रदर्शन लेते हैं और फिर पठनीयता को ध्यान में रखते हैं।

  • एक सामान्य Swap विधि में एक अस्थायी चर का उपयोग करें। (पूर्ण सर्वश्रेष्ठ प्रदर्शन, इनलाइन अस्थायी चर के आगे)
  • Interlocked.Exchange उपयोग करें (मेरे मशीन पर 5.9 गुना धीमी गति से, लेकिन यह एकमात्र विकल्प है यदि एकाधिक थ्रेड इन वैरिएड को एक साथ गमागमन करेंगे।)

आप कभी भी ऐसा नहीं करना चाहिए:

  • कभी भी फ़्लोटिंग पॉइंट अंकगणित का उपयोग न करें। (धीमा, गोलाकार और अतिप्रवाह त्रुटियां, समझना मुश्किल)
  • कभी भी गैर-आदिम अंकगणितीय का उपयोग न करें (धीमा, अतिप्रवाह त्रुटियों, समझने में कठिनाई) Decimal एक सीपीयू आदिम नहीं है और आपके द्वारा एहसास से कहीं ज्यादा कोड का परिणाम है।
  • कभी भी अंकगणित अवधि का उपयोग न करें। या बिट हैक्स (धीमा, समझना मुश्किल है) यही संकलक का काम है यह कई विभिन्न प्लेटफार्मों के लिए ऑप्टिमाइज़ कर सकता है

क्योंकि हर कोई मुश्किल संख्याओं को प्यार करता है, यहां एक ऐसा कार्यक्रम है जो आपके विकल्पों की तुलना करता है। इसे विजुअल स्टूडियो के बाहर रिलीज मोड में चलाएं ताकि Swap इनलाइन कर सकें। मेरी मशीन पर परिणाम (विंडोज 7 64-बीट i5-3470):

 Inline: 00:00:00.7351931 Call: 00:00:00.7483503 Interlocked: 00:00:04.4076651 

कोड:

 class Program { static void Swap<T>(ref T obj1, ref T obj2) { var temp = obj1; obj1 = obj2; obj2 = temp; } static void Main(string[] args) { var a = new object(); var b = new object(); var s = new Stopwatch(); Swap(ref a, ref b); // JIT the swap method outside the stopwatch s.Restart(); for (var i = 0; i < 500000000; i++) { var temp = a; a = b; b = temp; } s.Stop(); Console.WriteLine("Inline temp: " + s.Elapsed); s.Restart(); for (var i = 0; i < 500000000; i++) { Swap(ref a, ref b); } s.Stop(); Console.WriteLine("Call: " + s.Elapsed); s.Restart(); for (var i = 0; i < 500000000; i++) { b = Interlocked.Exchange(ref a, b); } s.Stop(); Console.WriteLine("Interlocked: " + s.Elapsed); Console.ReadKey(); } } 

<पदावनत>

आप इसे बुनियादी गणित का उपयोग करके 3 लाइनों में कर सकते हैं – मेरे उदाहरण में मैं गुणन का उपयोग किया है, लेकिन साधारण इसके अलावा भी काम करेगा।

 float startAngle = 159.9F; float stopAngle = 355.87F; startAngle = startAngle * stopAngle; stopAngle = startAngle / stopAngle; startAngle = startAngle / stopAngle; 

संपादित करें: जैसा कि टिप्पणियों में बताया गया है, यह y = 0 के रूप में काम नहीं करेगा क्योंकि यह शून्य त्रुटि से विभाजित करता है जिसे मैंने नहीं माना था। तो वैकल्पिक रूप से प्रस्तुत +/- समाधान सबसे अच्छा तरीका होगा।

</ पदावनत>


अपने कोड को तुरंत समझने के लिए, मुझे इस तरह कुछ करने की अधिक संभावना होगी। [हमेशा गरीब व्यक्ति के बारे में सोचें, जो आपके कोड को बनाए रखने के लिए है]:

 static bool Swap<T>(ref T x, ref T y) { try { T t = y; y = x; x = t; return true; } catch { return false; } } 

और फिर आप इसे कोड की एक पंक्ति में कर सकते हैं:

 float startAngle = 159.9F float stopAngle = 355.87F Swap<float>(ref startAngle, ref stopAngle); 

या …

 MyObject obj1 = new MyObject("object1"); MyObject obj2 = new MyObject("object2"); Swap<MyObject>(ref obj1, ref obj2); 

रात के खाने की तरह किया … अब आप किसी भी प्रकार के ऑब्जेक्ट में प्रवेश कर सकते हैं और उन्हें आसपास स्विच कर सकते हैं …

यदि आप decimal का उपयोग करने से double कर बदल सकते हैं तो आप Interlocked क्लास का उपयोग कर सकते हैं। संभवतया यह वेरिएबल प्रदर्शन के आधार पर गमागमन का एक अच्छा तरीका होगा। XOR से भी थोड़ा अधिक पठनीय

 var startAngle = 159.9d; var stopAngle = 355.87d; stopAngle = Interlocked.Exchange(ref startAngle, stopAngle); 

एमएसडीएन: इंटरलॉक। एक्सक्श्वेन विधि (डबल, डबल)

पूर्णता के लिए, यहां द्विआधारी XOR स्वैप है:

 int x = 42; int y = 51236; x ^= y; y ^= x; x ^= y; 

यह सभी परमाणु वस्तुओं / संदर्भों के लिए काम करता है, क्योंकि यह सीधे बाइट्स के साथ सौदा करता है, लेकिन दशमलव पर काम करने के लिए असुरक्षित संदर्भ की आवश्यकता हो सकती है, या यदि आप वास्तव में परेशानी महसूस कर रहे हैं, संकेतक और यह कुछ परिस्थितियों में भी अस्थायी चर से धीमी हो सकती है।

अपने पर्यावरण से सावधान!

उदाहरण के लिए, यह ECMAscript में काम नहीं करता है

 y ^= x ^= y ^= x; 

लेकिन यह करता है

 x ^= y ^= x; y ^= x; 

मेरी सलाह है? संभव के रूप में छोटा अनुमान

बस एक पंक्ति में 2 नंबरों को स्वैप करने का आसान तरीका:

 a=(a+b)-(b=a); 

उदाहरण: ए = 1, बी = 2

चरण 1: ए = (1 + 2) – (बी = 1)

चरण 2: ए = 3-1

=> ए = 2 और बी = 1


कुशल तरीके से उपयोग करना है:

सी प्रोग्रामिंग: (x ^= y), (y ^= x), (x ^= y);

जावा: x = x ^ y ^ (y = x);

पायथन: x, y = y, x

नोट: सबसे आम गलती लोग बनाते हैं: // bitwise XOR का प्रयोग करके स्वैप (सी / सी ++ में गलत समाधान)

 x ^= y ^= x ^= y; 

स्रोत: GeeksforGeek

 a = a + b b = a - b a = a - b 

द्विआधारी प्रकार के लिए आप इस कायरता चाल का उपयोग कर सकते हैं:

 a %= b %= a %= b; 

जब तक ए और बी सटीक वही चर नहीं हो (जैसे कि एक ही मेमोरी के लिए उपनाम) यह काम करता है

मुझे उम्मीद है कि यह मदद कर सकता है …

 using System; public class Program { public static void Main() { int a = 1234; int b = 4321; Console.WriteLine("Before: a {0} and b {1}", a, b); b = b - a; a = a + b; b = a - b; Console.WriteLine("After: a {0} and b {1}", a, b); } } 
 startAngle = (startAngle + stopAngle) - (stopAngle = startAngle); 

यहां एक पंक्ति में एक और तरीका है:

 decimal a = 159.9m; decimal b = 355.87m; a = b + (b = a) - b; 

हम एक साधारण चाल करके ऐसा कर सकते हैं

 a = 20; b = 30; a = a+b; // add both the number now a has value 50 b = ab; // here we are extracting one number from the sum by sub a = ab; // the number so obtained in above help us to fetch the alternate number from sum System.out.print("swapped numbers are a = "+ a+"b = "+ b); 

सी # 7 के साथ, आप एक पंक्ति में वांछित स्वैप प्राप्त करने के लिए ट्यूपल डिकोन्स्ट्रक्शन का उपयोग कर सकते हैं, और यह स्पष्ट है कि क्या चल रहा है।

 decimal startAngle = Convert.ToDecimal(159.9); decimal stopAngle = Convert.ToDecimal(355.87); (startAngle, stopAngle) = (stopAngle, startAngle); 

दो चर को स्वैप करने के लिए कुछ अलग प्रक्रिया है

 //process one a=b+a; b=ab; a=ab; printf("a= %db= %d",a,b); //process two a=5; b=10; a=a+b-(b=a); printf("\na= %db= %d",a,b); //process three a=5; b=10; a=a^b; b=a^b; a=b^a; printf("\na= %db= %d",a,b); //process four a=5; b=10; a=b-~a-1; b=a+~b+1; a=a+~b+1; printf("\na= %db= %d",a,b); 

यदि आप 2 स्ट्रिंग चर को स्वैप करना चाहते हैं:

 a = (a+b).Substring((b=a).Length); 

सी # 7 में:

 (startAngle, stopAngle) = (stopAngle, startAngle); 
 var a = 15; var b = -214; a = b | !(b = a); 

यह महान काम करता है

दो चर गमागमन के लिए बहुत सरल कोड:

 static void Main(string[] args) { Console.WriteLine("Prof.Owais ahmed"); Console.WriteLine("Swapping two variables"); Console.WriteLine("Enter your first number "); int x = Convert.ToInt32(Console.ReadLine()); Console.WriteLine("Enter your first number "); int y = Convert.ToInt32(Console.ReadLine()); Console.WriteLine("your vlaue of x is="+x+"\nyour value of y is="+y); int z = x; x = y; y = z; Console.WriteLine("after Swapping value of x is="+x+"/nyour value of y is="+y); Console.ReadLine(); } 

आप निम्न कोड को आज़मा सकते हैं यह अन्य कोड से कहीं ज्यादा बेहतर है।

 a = a + b; b = a - b; a = a - b;