🐻 🅱️ 👍🏾 पूर्वानुमानित यादृच्छिक क्रम उत्पन्न करना: क्रमपरिवर्तन के लिए एक अलग दृष्टिकोण 🤚🏿 😰 🎗️

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

कार्य काफी सरल है और हमने इसे जल्दी से हल किया। और समाधान इस प्रकार था: हमारे पास n प्रश्न हैं। कॉम्बिनेटरिक्स से, हम जानते हैं कि अगर हमारे पास n> 1 तत्व हैं, तो स्थानों में तत्वों को फिर से व्यवस्थित करके, हम इन तत्वों के विभिन्न अनुक्रम प्राप्त कर सकते हैं, जहां विभिन्न अनुक्रमों की अधिकतम संख्या है $n!$ । तो यह तय किया गया था, हम इसे लिखते हैं इसका मतलब है कि एक फ़ंक्शन, हम वहां फैक्टरियल की गणना करते हैं, एनटीटी सीक्वेंस उत्पन्न करते हैं, और संख्या एन खुद को यादृच्छिक रूप से उत्पन्न करते हैं और इसे डेटाबेस में लिखते हैं। हम परीक्षण करने के लिए और~~उत्पादन में~~hrenak-hrenak भेजते हैं। और सब कुछ सामान्य लग रहा है, लेकिन अगर कुछ अप्रत्याशित नहीं हुआ था, तो यह लेख नहीं होगा।

क्या हुआ

और हुआ $21! = ‭51 090 942 171 709 440 000‬$ । संख्या के तथ्यात्मक मूल्य को 20 से अधिक (वास्तव में 13) रखना एक बड़ी समस्या थी जिसे कोड लिखते समय ध्यान नहीं दिया गया था। नतीजतन, अगर अधिक सवाल थे, तो निश्चित रूप से कुछ भी काम नहीं किया। किसी तरह दोष को हल करना आवश्यक था। एक विकल्प केवल सरणी को विभाजित करने के लिए था, उप-सरणियों में तत्वों को मिलाएं, और फिर उन्हें स्वयं मिश्रण करें। जैसे, यह विकल्प स्वीकार्य है, लेकिन चूंकि सभी ने मुझे फिक्स के साथ सौंपा, मैंने दूसरे रास्ते पर जाने का फैसला किया।

ओह नया अद्भुत तरीका

अंत में एक समाधान पर निर्णय लेने के लिए, मैंने अपने आप से एक सवाल पूछा - "और हमें क्या चाहिए, एक विशिष्ट उपयोगकर्ता के लिए एक विशिष्ट अनुक्रम उत्पन्न करें या इसे पुनरावृत्ति की संभावना के साथ मिलाएं?"। चूंकि यह दूसरा था जो आवश्यक था, मैंने एक अलग कोण से समस्या और क्रमपरिवर्तन को देखने का फैसला किया। आखिरकार, एन तत्वों में से एक यादृच्छिक अनुक्रम बनाना आवश्यक था, और अनुक्रम में स्वयं तत्वों को एक बार मिलना चाहिए। इसका मतलब है कि आप बेतरतीब ढंग से तत्वों में से एक का चयन कर सकते हैं, इसे अनुक्रम में पहला बना सकते हैं, और अगले को उसी यादृच्छिक तरीके से चुन सकते हैं, लेकिन शेष तत्वों से। और इसलिए n बार, जब तक हम अपने नए अनुक्रम को इकट्ठा नहीं करते।

यह विचार को लागू करने और कार्य कोड लिखने के लिए बना हुआ है। सबसे पहले, हमें एक सरणी की आवश्यकता है जिसे हम मिश्रण करना चाहते हैं:

public static int[] generateArray(int n) {
	int[] array = new int[n];

	for (int i = 0; i < n; i++) {
		array[i] = i;
	}

	return array;
}

, , Java :

int[] arrayCopy = Array.copyOf(mainArray, mainArray.length);

public static int[] shuffleArray(int[] array, Random rand) {
	int[] shuffledArray = new int[array.length];

	for (int i = 0; i < array.length; i++) {
		int origIndex = rand.nextInt(array.length - i);
		shuffledArray[i] = array[origIndex];

		int temp = array[origIndex];
		array[origIndex] = array[array.length - i - 1];
		array[array.length - i - 1] = temp;
	}

	return shuffledArray;
}

, , seed . , , , - :

public static void main(String[] args) {
	int[] mainArray = generateArray(30);
	int[] arrayCopy = Arrays.copyOf(mainArray, mainArray.length);

	Random rand = new Random(419L);
	int[] shuffledArray = shuffleArray(arrayCopy, rand);

	for (int i = 0; i < shuffledArray.length; i++) {
		System.out.print(shuffledArray[i] + " ");
	}

	System.out.println();
}

, . $O(n)$ , :

import java.util.Random;
import java.util.Arrays;

public class Shuffle {
	public static void main(String[] args) {
		int[] mainArray = generateArray(30);
		int[] arrayCopy = Arrays.copyOf(mainArray, mainArray.length);

		Random rand = new Random(419L);
		int[] shuffledArray = shuffleArray(arrayCopy, rand);

		for (int i = 0; i < shuffledArray.length; i++) {
			System.out.print(shuffledArray[i] + " ");
		}

		System.out.println();
	}

	public static int[] generateArray(int n) {
		int[] array = new int[n];

		for (int i = 0; i < n; i++) {
			array[i] = i;
		}

		return array;
	}

	public static int[] shuffleArray(int[] array, Random rand) {
		int[] shuffledArray = new int[array.length];

		for (int i = 0; i < array.length; i++) {
			int origIndex = rand.nextInt(array.length - i);
			shuffledArray[i] = array[origIndex];

			int temp = array[origIndex];
			array[origIndex] = array[array.length - i - 1];
			array[array.length - i - 1] = temp;
		}

		return shuffledArray;
	}
}

, , . , ( ), n- . , :

public static int[] subArrayElem(int nth, int elemNumber) {
	int[] sequence = new int[elemNumber];

	for (int i = 1; i <= elemNumber; i++) {
		sequence[elemNumber - i] = nth % i;
		nth /= i;
	}

	return sequence;
}

, , . -, . , :

public static int[] shuffleArray(int[] array, int nth) {
	int[] shuffledArray = new int[array.length];
	int[] sequence = subArrayElem(nth, array.length);

	for (int i = 0; i < array.length; i++) {
		int origIndex = sequence[i];
		shuffledArray[i] = array[origIndex];
		shiftArray(array, origIndex);
	}

	return shuffledArray;
}

public static void shiftArray(int[] array, int index) {
	for (int i = index; i < array.length - 1; i++) {
		array[i] = array[i + 1];
	}
}

, , .

, . BigInteger, . - , . - . , , - , . , , ? .

UPD:

, Java, java.util.Collections.shuffle() . Java .

पूर्वानुमानित यादृच्छिक क्रम उत्पन्न करना: क्रमपरिवर्तन के लिए एक अलग दृष्टिकोण

क्या हुआ

ओह नया अद्भुत तरीका

More articles: