C# Language
किसी सरणी के परिपत्र रोटेशन के लिए ओ (एन) एल्गोरिदम

परिचय

एक सामान्य विधि का उदाहरण जो किसी दिए गए बदलाव से एक सरणी को घुमाता है

मैं यह बताना चाहूंगा कि जब स्थानांतरण मूल्य नकारात्मक है तो हम बाएं घूमते हैं और जब मूल्य सकारात्मक होता है तो हम सही घूमते हैं।

    public static void Main()
    {
        int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        int shiftCount = 1;
        Rotate(ref array, shiftCount);
        Console.WriteLine(string.Join(", ", array));
        // Output: [10, 1, 2, 3, 4, 5, 6, 7, 8, 9]

        array = new []{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        shiftCount = 15;
        Rotate(ref array, shiftCount);
        Console.WriteLine(string.Join(", ", array));
        // Output: [6, 7, 8, 9, 10, 1, 2, 3, 4, 5]

        array = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        shiftCount = -1;
        Rotate(ref array, shiftCount);
        Console.WriteLine(string.Join(", ", array));
        // Output: [2, 3, 4, 5, 6, 7, 8, 9, 10, 1]

        array = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        shiftCount = -35;
        Rotate(ref array, shiftCount);
        Console.WriteLine(string.Join(", ", array));
        // Output: [6, 7, 8, 9, 10, 1, 2, 3, 4, 5]
    }

    private static void Rotate<T>(ref T[] array, int shiftCount)
    {
        T[] backupArray= new T[array.Length];

        for (int index = 0; index < array.Length; index++)
        {
            backupArray[(index + array.Length + shiftCount % array.Length) % array.Length] = array[index];
        }

        array = backupArray;
    }

इस कोड में जो चीज महत्वपूर्ण है, वह सूत्र है जिसके साथ हम रोटेशन के बाद नए सूचकांक मूल्य को पाते हैं।

(index + array.Length + shiftCount% array.Length)% array.ength

यहाँ इसके बारे में कुछ और जानकारी दी गई है:

(shiftCount% array.Length) -> हम ऐरे की लंबाई में होने के लिए शिफ्टिंग वैल्यू को सामान्य करते हैं (क्योंकि एक एरे में लंबाई 10 के साथ, शिफ्टिंग 1 या 11 एक ही चीज है, वही -1 और -11 के लिए जाती है) ।

array.Length + (shiftCount% array.Length) -> यह बाएं घुमाव के कारण किया जाता है यह सुनिश्चित करने के लिए कि हम एक नकारात्मक सूचकांक में नहीं जाते हैं, लेकिन इसे सरणी के अंत में घुमाएं। सूचकांक 0 के लिए लंबाई 10 और रोटेशन -1 के साथ सरणी के बिना हम एक नकारात्मक संख्या (-1) में जाएंगे और वास्तविक रोटेशन इंडेक्स मान प्राप्त नहीं करेंगे, जो कि 9. (10 + -1% 10) = है 9)

index + array.Length + (shiftCount% array.Length) -> यहां कहने के लिए बहुत कुछ नहीं है क्योंकि हम नए इंडेक्स प्राप्त करने के लिए इंडेक्स के रोटेशन को लागू करते हैं। (0 + 10 + (-1% 10) = 9)

index + array.Length + (shiftCount% array.Length)% array.ength -> दूसरा सामान्यीकरण यह सुनिश्चित कर रहा है कि नया इंडेक्स वैल्यू सरणी के बाहर नहीं जाता है, लेकिन एरे की शुरुआत में वैल्यू को घुमाता है। यह सही घुमावों के लिए है, क्योंकि अनुक्रमणिका 9 के लिए बिना लंबाई 10 के साथ एक सरणी में और एक रोटेशन 1 हम सूचकांक 10 में जाएंगे, जो कि सरणी के बाहर है, और वास्तविक रोटेशन सूचकांक मान प्राप्त नहीं है 0. (9 + 10 + (1% 10))% 10 = 0)