ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆ ಜನರೇಟರ್. ಅಪಘಾತ, ಕಾಕತಾಳೀಯ, ಮಾದರಿ

ನಾನು ಕೇವಲ ಈ ಉದ್ಗಾರದೊಂದಿಗೆ ಲೇಖನವನ್ನು ಪ್ರಾರಂಭಿಸಲಿಲ್ಲ. ಇದು ಸಂಭವಿಸಿದೆ, ಪ್ರೋಗ್ರಾಮರ್ ತನ್ನ ಆರ್ಸೆನಲ್ನಲ್ಲಿ ಅನುಕೂಲಕರವಾದ ಸಾಧನವನ್ನು ಹೊಂದಿದ್ದು ಅದು ನಿರ್ದಿಷ್ಟ ಮಧ್ಯಂತರದಲ್ಲಿ ಯಾದೃಚ್ಛಿಕ ಪೂರ್ಣಾಂಕವನ್ನು ಪಡೆಯಲು ಅನುಮತಿಸುತ್ತದೆ. ಇತರ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಫಂಕ್ಷನ್‌ಗಳು 0 ರಿಂದ 1 ರವರೆಗಿನ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಒಂದು ಭಿನ್ನರಾಶಿ ಸಂಖ್ಯೆಯನ್ನು ರಚಿಸುತ್ತವೆ. ಇದು ಒಂದು ನಿರ್ದಿಷ್ಟ ಶ್ರೇಣಿಯಲ್ಲಿ ಯಾದೃಚ್ಛಿಕ ಅನುಕ್ರಮವನ್ನು ಪಡೆಯಲು ನೀವು ಹೆಚ್ಚು ಶ್ರಮಿಸಬೇಕಾಗುತ್ತದೆ 1 ರಿಂದ 5.

ಅನುಕೂಲಕರ ಸಾಧನವನ್ನು ಪರಿಶೀಲಿಸಬೇಕಾಗಿದೆ, ಆಗಾಗ್ಗೆ RNG ಗಳು ಉತ್ತಮ ಗುಣಮಟ್ಟವನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ ಮತ್ತು ಕಳಪೆ ಮಿಶ್ರಿತ ಹುಸಿ ಅನುಕ್ರಮಗಳನ್ನು ತೊಡೆದುಹಾಕಲು ಉತ್ಪತ್ತಿಯಾಗುವ ಸಂಖ್ಯೆಗಳ ಯಾದೃಚ್ಛಿಕತೆಯನ್ನು ಹೆಚ್ಚಿಸಲು ನೀವು ಹೆಚ್ಚುವರಿಯಾಗಿ ಗಣಿತವನ್ನು ಅಭ್ಯಾಸ ಮಾಡಬೇಕು. ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ರಹಸ್ಯಗಳು, ಹಣಕಾಸು ಸಂಪನ್ಮೂಲಗಳು, ಮನರಂಜನೆ, ಮಾಡೆಲಿಂಗ್, ನಿರ್ಣಾಯಕ ಸ್ವಯಂಚಾಲಿತ ನಿಯಂತ್ರಣ ವ್ಯವಸ್ಥೆಗಳ ಪರೀಕ್ಷೆ, ಪರೀಕ್ಷಾ ಕಾರ್ಯಕ್ರಮಗಳೊಂದಿಗೆ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳನ್ನು ನಂಬುತ್ತೇವೆ, ಆದ್ದರಿಂದ ಮೌಲ್ಯದ ಮಧ್ಯಂತರದಿಂದ ಡಿಗ್ರಿಯವರೆಗೆ ವಿವಿಧ ನಿರ್ದಿಷ್ಟ ಗುಣಲಕ್ಷಣಗಳೊಂದಿಗೆ ಸರಣಿಯ ಅನನ್ಯ ಅನುಕ್ರಮವನ್ನು ಹೊಂದುವುದು ಬಹಳ ಮುಖ್ಯ. ಅನುಕ್ರಮ ಸಂಖ್ಯೆಗಳ ಮಿಶ್ರಣ.

ವಿಫಲವಾದ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಯ ಉತ್ಪಾದನೆಯ ಉದಾಹರಣೆಯನ್ನು ನಾನು ನಿಮಗೆ ನೀಡುತ್ತೇನೆ. 1993 ರಲ್ಲಿ, 640x480 ರೆಸಲ್ಯೂಶನ್ ಹೊಂದಿರುವ ಬಣ್ಣರಹಿತ VGA ಮಾನಿಟರ್ ಅನ್ನು ಉತ್ತಮವೆಂದು ಪರಿಗಣಿಸಿದಾಗ ಮತ್ತು ಪ್ರೋಗ್ರಾಮರ್ಗಳ ಕಣ್ಣುಗಳು ಕಡಿಮೆ ದಣಿದಿದ್ದಾಗ, ವಿರೋಧಾಭಾಸ DBMS ವ್ಯಾಪಕವಾಗಿ ಹರಡಿತು. ಬೊರ್ಲ್ಯಾಂಡ್ ಇಂಟರ್‌ನ್ಯಾಶನಲ್‌ನ ದುರಾಸೆಯ ಜನರು ಹೆಚ್ಚು ಹಣವನ್ನು ಗಳಿಸಲು ನಿರ್ಧರಿಸಿದರು ಮತ್ತು ನೆಟ್‌ವರ್ಕ್ ಪ್ರವೇಶಕ್ಕಾಗಿ 10 ಅಂಕೆಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಕೀಯ ಅಗತ್ಯವಿದೆ. ನೀವು ಹೆಚ್ಚು ಕೀಗಳನ್ನು ನಮೂದಿಸಿದರೆ, ಹೆಚ್ಚಿನ ಬಳಕೆದಾರರು ಡೇಟಾಬೇಸ್‌ಗೆ ಏಕಕಾಲದಲ್ಲಿ ಸಂಪರ್ಕಿಸಬಹುದು.

ಈಗ ನಾನು ನನ್ನ ಯಶಸ್ಸಿನ ಬಗ್ಗೆ ಹೆಮ್ಮೆಪಡಲು ಪ್ರಾರಂಭಿಸುತ್ತೇನೆ :). ವಿಭಿನ್ನ ರೀತಿಯಲ್ಲಿ, 3 ಕೀಗಳು ನನ್ನ ಬಳಿಗೆ ಬಂದವು ಮತ್ತು ಅನುಕ್ರಮವು ಹುಸಿ-ಯಾದೃಚ್ಛಿಕ ಮತ್ತು ಕಳಪೆ ಮಿಶ್ರಣವಾಗಿದೆ ಎಂದು ನನಗೆ ಅರ್ಥವಾಯಿತು. ಯಾವುದೇ ತಂತ್ರಜ್ಞಾನವಿಲ್ಲದೆ, ಸಂಕೀರ್ಣ ಲೆಕ್ಕಾಚಾರಗಳು ಮತ್ತು ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಇಲ್ಲದೆ, ನಾನು ಈ ಕೀಗಳ ಯಾವುದೇ ಸಂಖ್ಯೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ನಿರ್ವಹಿಸುತ್ತಿದ್ದೆ. ಸಹಜವಾಗಿ, ಬೊರ್ಲ್ಯಾಂಡ್ ಕಂಪನಿಯು ದೊಡ್ಡ ನಷ್ಟವನ್ನು ಅನುಭವಿಸಲಿಲ್ಲ, ಆದರೆ ನೀವು ಈಗಾಗಲೇ ರಕ್ಷಣೆಯಲ್ಲಿ ತೊಡಗಿರುವ ಕಾರಣ, ನಂತರ ಅದನ್ನು ಚೆನ್ನಾಗಿ ಮಾಡಿ, ಅಥವಾ ಅನುಪಯುಕ್ತ ಕೆಲಸದಲ್ಲಿ ಸಮಯವನ್ನು ವ್ಯರ್ಥ ಮಾಡಬೇಡಿ. ನಾನು ಇದರಿಂದ ನೈತಿಕತೆಯನ್ನು ಸೆಳೆಯುವುದಿಲ್ಲ, RNG ಒಂದು ಪ್ರಮುಖ ವಿಷಯವಾಗಿದೆ ಎಂಬುದು ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.

ಹುಸಿ-ಯಾದೃಚ್ಛಿಕ ಅನುಕ್ರಮಗಳ ರಕ್ಷಣೆಯಲ್ಲಿ, ಕೆಲವೊಮ್ಮೆ ಅವು ಅಗತ್ಯವೆಂದು ನಾನು ಹೇಳುತ್ತೇನೆ, ಉದಾಹರಣೆಗೆ, ಭದ್ರತಾ ಕೀಲಿಯನ್ನು ಸೂತ್ರವನ್ನು ಬಳಸಿಕೊಂಡು ಲೆಕ್ಕಹಾಕಿದಾಗ ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಸ್ಥಳೀಯ ಮೋಡ್ನಲ್ಲಿ ಕೀಲಿಯನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಪರಿಶೀಲಿಸಲು ನಿರ್ಧರಿಸಿದಾಗ. 1993 ರಲ್ಲಿ, ಇಂಟರ್ನೆಟ್ ವ್ಯಾಪಕವಾಗಿರಲಿಲ್ಲ ಮತ್ತು ಪ್ರೋಗ್ರಾಮರ್‌ಗಳು ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಪರೀಕ್ಷಿಸದೆಯೇ ಅನುಕ್ರಮ ಅಲ್ಗಾರಿದಮ್‌ಗಳೊಂದಿಗೆ ಬರಬೇಕಾಯಿತು. ಆದರೆ ಚೆನ್ನಾಗಿ ಮಿಶ್ರಣ ಮಾಡಲು ಮರೆಯದಿರಿ. ನೆಟ್‌ವರ್ಕ್‌ಗಳ ಆಧುನಿಕ ಅಭಿವೃದ್ಧಿಯೊಂದಿಗೆ, ಪರಿಶೀಲನಾ ಸರ್ವರ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರೋಗ್ರಾಂಗಳು ಮತ್ತು ಸಲಕರಣೆಗಳ ಸರಣಿ ಸಂಖ್ಯೆಯನ್ನು ಪರಿಶೀಲಿಸಲು ಸಾಧ್ಯವಿದೆ. ಈ ವ್ಯವಸ್ಥೆಯು ನಕಲಿಗೆ ಗಮನಾರ್ಹವಾಗಿ ಪ್ರತಿರೋಧವನ್ನು ಹೆಚ್ಚಿಸಿದೆ, ಆದರೆ ಇದರ ಹೊರತಾಗಿಯೂ, ಸಾಫ್ಟ್‌ವೇರ್‌ನ ಅನಧಿಕೃತ ಬಳಕೆಯು ಇನ್ನೂ ಸಂಭವಿಸುತ್ತದೆ ಎಂಬುದು ರಹಸ್ಯವಲ್ಲ.

ತೀರ್ಮಾನವು ಇದು: ಬೀಗಗಳು ಮತ್ತು ಮಲಬದ್ಧತೆಗಳನ್ನು ಪ್ರಾಮಾಣಿಕ ಜನರಿಂದ ಸ್ಥಾಪಿಸಲಾಗಿದೆ.

1C ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿನ ವಸ್ತುವಿನ ಕಾರ್ಯಾಚರಣೆಯು ಅತ್ಯಂತ ಸರಳವಾಗಿದೆ, ಆದರೂ ಕೆಲವು ವಿಶಿಷ್ಟತೆಗಳಿವೆ.

RNG = NewRandomNumberGenerator(Initialization); //ಇಲ್ಲಿ ನೀವು ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಯ ಜನರೇಟರ್‌ನ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಬದಲಾಯಿಸಬಹುದು, ಸಂಖ್ಯೆಯ ಪ್ರಾರಂಭವನ್ನು ಬದಲಾಯಿಸುವುದು ವಿಭಿನ್ನ ಫಲಿತಾಂಶಗಳನ್ನು ನೀಡುತ್ತದೆ RNG.RandomNumber(1, SettingsOption);

ನೀವು ಇನಿಶಿಯಲೈಸೇಶನ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದರೆ, ನಂತರ ಅನುಕ್ರಮಗಳು ಯಾದೃಚ್ಛಿಕವಾಗಿ ಉತ್ಪತ್ತಿಯಾಗುತ್ತವೆ, ತಮ್ಮನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತವೆ. ನೀಡಲಾದ ಪ್ರಾರಂಭಿಕ ಸಂಖ್ಯೆಯು ಊಹಿಸಬಹುದಾದ ಅನುಕ್ರಮವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಇದು ಕೆಲವೊಮ್ಮೆ ಅಗತ್ಯ ಮತ್ತು ಉಪಯುಕ್ತವಾಗಿದೆ. ಮತ್ತು ನೀವು ಪ್ರತಿ ಬಾರಿಯೂ ವಿಭಿನ್ನ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದರೆ, ನೀವು ಸಂಖ್ಯೆಗಳ ಅನುಕ್ರಮದ ಉತ್ತಮ ಮಿಶ್ರಣವನ್ನು ಪಡೆಯುತ್ತೀರಿ.

1C ಯಲ್ಲಿ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಯ ಜನರೇಟರ್ನ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಅಧ್ಯಯನ ಮಾಡಲು, ನಾನು ಒಂದೆರಡು ಚಿಕಿತ್ಸೆಯನ್ನು ರಚಿಸಿದ್ದೇನೆ ಮತ್ತು ಆಟದ ರೂಪದಲ್ಲಿ ಒಂದನ್ನು ಹೆಚ್ಚು ಆಸಕ್ತಿದಾಯಕವಾಗಿಸಲು, ಆದರೆ ಆಟವು ನಂತರ, ವ್ಯವಹಾರವು ಮೊದಲು.

CurrentUniversalDateInMilliseconds() ಫಂಕ್ಷನ್‌ನಿಂದ ಜನರೇಟರ್ ಅನ್ನು ನಿರಂತರವಾಗಿ ಆರಂಭಿಸುವುದರೊಂದಿಗೆ, 0 ರಿಂದ 10000 ವರೆಗಿನ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ 500 ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳನ್ನು ರಚಿಸಲಾಗಿದೆ. ರೇಖಾಚಿತ್ರವು ಮೌಲ್ಯಗಳ ಉತ್ತಮ ವಿತರಣೆಯನ್ನು ತೋರಿಸುತ್ತದೆ. ಅಲಂಕಾರಿಕ ಮಾದರಿ. Y ಅಕ್ಷದಲ್ಲಿ ಸಂಖ್ಯೆಯ ಮೌಲ್ಯ, X ಅಕ್ಷದಲ್ಲಿ ಪುನರಾವರ್ತನೆ ಸಂಖ್ಯೆ.

ಬಿಂದುಗಳ ಸ್ಥಾನಗಳು ಸಾಕಷ್ಟು ವಿರಳವಾಗಿವೆ, ಅವು ಬಹುತೇಕ ಪರಸ್ಪರ ಅಂಟಿಕೊಳ್ಳುವುದಿಲ್ಲ, ಇದು ತುಂಬಾ ಒಳ್ಳೆಯದು, ಅಂದರೆ ಉತ್ಪತ್ತಿಯಾಗುವ ಸಂಖ್ಯೆಗಳು ಬಹಳ ವೈವಿಧ್ಯಮಯವಾಗಿವೆ.

ರೇಖಾಚಿತ್ರದ ಕೆಟ್ಟ ಆವೃತ್ತಿಯನ್ನು ಕೃತಕವಾಗಿ ರಚಿಸೋಣ:

ಒಳ್ಳೆಯ ಪೀಳಿಗೆಯಲ್ಲಿ ಈ ರೀತಿ ಆಗಬಾರದು.

ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಯ ಜನರೇಟರ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳು ಬಹಳ ಮುಖ್ಯವಾದ ಅಂಶವಾಗಿದೆ. ಅವುಗಳಲ್ಲಿ ಕೆಲವು ಇವೆ, ಆದರೆ ಎಲ್ಲವೂ ಅವುಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ.

ಈ ಸೆಟ್ಟಿಂಗ್‌ನೊಂದಿಗೆ, 0 ರಿಂದ 10000 ರವರೆಗಿನ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ 500 ಸಂಖ್ಯೆಗಳ ಅನುಕ್ರಮವು ರೂಪುಗೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಜನರೇಟರ್ ಅನ್ನು ನಿರಂತರವಾಗಿ ಹೊಸ ಸಂಖ್ಯೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ.

ಜನರೇಟರ್ ನೀಡಿದ ನಕಲಿ ಸಂಖ್ಯೆಗಳು ಇವೆಯೇ ಎಂದು ನೋಡಲು, ಮೌಲ್ಯಗಳ ರಚನಾತ್ಮಕ ಕೋಷ್ಟಕವನ್ನು ಈ ಹಿಂದೆ ಮೌಲ್ಯಗಳ ಮೂಲಕ ವಿಂಗಡಿಸಿ ನೋಡೋಣ.

ವಿಂಗಡಿಸಲಾದ ಪಟ್ಟಿಯ ತ್ವರಿತ ದೃಶ್ಯ ಪರಿಶೀಲನೆಯು ಪುನರಾವರ್ತನೆಗಳಿವೆ ಎಂದು ತೋರಿಸಿದೆ, ಆದರೂ ಅವು ಸಂಭವಿಸುವ ಸಾಧ್ಯತೆ ಕಡಿಮೆ. ಪೀಳಿಗೆಗೆ ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಸಂಖ್ಯೆಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ, ಆದರೆ 10 ಮತ್ತು 30 ಹಂತಗಳಲ್ಲಿ ಸಂಖ್ಯೆಗಳನ್ನು ಪುನರಾವರ್ತಿಸಲಾಯಿತು.

ನಾವು ತೀರ್ಮಾನಿಸುತ್ತೇವೆ: ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆ ಜನರೇಟರ್ ವಸ್ತುವು ಪುನರಾವರ್ತಿತ ಸಂಖ್ಯೆಗಳನ್ನು ರಚಿಸಬಹುದು.

ಇದು ಕೆಲವೊಮ್ಮೆ ಸ್ವೀಕಾರಾರ್ಹವಲ್ಲ. ಉದಾಹರಣೆಗೆ, ನಿರ್ದಿಷ್ಟ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ತೆರೆಯಬಹುದಾದ ಬಳಕೆದಾರರಿಗೆ ತಿಳಿಸಲು ನಾವು ಯಾದೃಚ್ಛಿಕ ಡಾಕ್ಯುಮೆಂಟ್ ಸಂಖ್ಯೆಯನ್ನು ಅಸಮಂಜಸವಾಗಿ ರಚಿಸುತ್ತೇವೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಪುನರಾವರ್ತನೆಗಳು ಸ್ವೀಕಾರಾರ್ಹವಲ್ಲ, ಇಲ್ಲದಿದ್ದರೆ, ಪುನರಾವರ್ತಿಸಿದಾಗ, ಯಾವ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ತೆರೆಯಬೇಕು ಎಂಬುದು ಅಸ್ಪಷ್ಟವಾಗಿರುತ್ತದೆ.

ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆ ಏಕೆ ಬೇಕು? ದುರಸ್ತಿಗಾಗಿ ಹಸ್ತಾಂತರಿಸಲಾದ ಸಲಕರಣೆಗಳಿಗಾಗಿ ನಾವು ನಮ್ಮ ಪಾಲುದಾರರ ಡಾಕ್ಯುಮೆಂಟ್ ಸಂಖ್ಯೆಗಳನ್ನು ನೀಡುತ್ತೇವೆ ಎಂದು ಹೇಳೋಣ. ನೀವು ನಿರಂತರ ಅನುಕ್ರಮ ಸಂಖ್ಯೆಗಳನ್ನು ನೀಡಬಹುದು, ಆದರೆ ಕ್ಲೈಂಟ್, ಒಂದು ಸಂಖ್ಯೆಯನ್ನು ಹೊಂದಿರುವ, ಕನಿಷ್ಠ ನೆರೆಹೊರೆಯವರನ್ನು ನೋಡಬಹುದು ಮತ್ತು ಸಂಖ್ಯೆಯ ಮಧ್ಯಂತರವನ್ನು ತಿಳಿದುಕೊಳ್ಳುವುದರಿಂದ ಎಲ್ಲಾ ದಾಖಲೆಗಳನ್ನು ವೀಕ್ಷಿಸಬಹುದು. ನೀಡಿರುವ ಉದಾಹರಣೆಯಲ್ಲಿ, ಇದು ಅಂತಹ ರಹಸ್ಯವಲ್ಲ, ಆದರೆ ಕೆಲವೊಮ್ಮೆ ಇತರ ದಾಖಲೆಗಳಿಂದ ಮಾಹಿತಿಯನ್ನು ರಹಸ್ಯವಾಗಿಡಲು ಅಗತ್ಯವಾಗಿರುತ್ತದೆ.

ಪೀಳಿಗೆಯ ಸಂಖ್ಯೆಯ ಮೌಲ್ಯಗಳ ದೊಡ್ಡ ಮಧ್ಯಂತರಗಳೊಂದಿಗೆ, ಪುನರಾವರ್ತಿತ ಘಟನೆಗಳ ಸಂಭವನೀಯತೆ ಕಡಿಮೆಯಾಗುತ್ತದೆ, ಆದರೆ ಈವೆಂಟ್ ಸಂಭವಿಸಿದರೆ, ಅದು ಖಂಡಿತವಾಗಿಯೂ ಸಂಭವಿಸುತ್ತದೆ.

ವಿಶಿಷ್ಟತೆಗಾಗಿ ರಚಿಸಿದ ಸಂಖ್ಯೆಯನ್ನು ಪರಿಶೀಲಿಸುವುದು ಪರಿಹಾರವಾಗಿದೆ, ಆದರೆ ಬಹಳ ದೀರ್ಘವಾದ ಅನುಕ್ರಮಗಳಿಗೆ ಇದು ಸಾಕಷ್ಟು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ನಾವು ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಮಿಶ್ರಣದ ಬಗ್ಗೆ ಯೋಚಿಸಬೇಕಾಗಿದೆ, ಆದರೆ ಅದು ಕಾರ್ಯವನ್ನು ಹೆಚ್ಚು ಆಸಕ್ತಿಕರಗೊಳಿಸುತ್ತದೆ;).

ಚಾರ್ಟ್‌ನಲ್ಲಿ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರದರ್ಶಿಸುವಾಗ, 1000 ಮೌಲ್ಯಗಳನ್ನು ಸೇರಿಸಿದ ನಂತರ ನನ್ನ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಯು ಗಮನಾರ್ಹವಾಗಿ ನಿಧಾನಗೊಳ್ಳಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ “ಚಾರ್ಟ್ ಅನ್ನು ರಚಿಸಬೇಡಿ” ಎಂಬ ಚೆಕ್‌ಬಾಕ್ಸ್ ಇದೆ. ಸ್ಥಾಪಿಸಿದಾಗ, ದೀರ್ಘ ಅನುಕ್ರಮಗಳನ್ನು ಉತ್ಪಾದಿಸುವಾಗ ಕಾರ್ಯಾಚರಣೆಯ ವೇಗವು ಗಮನಾರ್ಹವಾಗಿ ಹೆಚ್ಚಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಸಂಶೋಧನೆ ಮಾಡುವಾಗ, ರಚಿಸಿದ ಸಂಖ್ಯೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹೊಂದಿಸುವಾಗ ಜಾಗರೂಕರಾಗಿರಿ.

ಜನರೇಟರ್‌ಗೆ ನಿರ್ದಿಷ್ಟ ಆರಂಭದ ಮೌಲ್ಯವನ್ನು ನೀಡಬಹುದು, ನಂತರ ನೀವು ಉತ್ಪಾದಿಸಲು ಎಷ್ಟು ಬಾರಿ ಒತ್ತಿದರೂ ಫಲಿತಾಂಶವು ಒಂದೇ ಆಗಿರುತ್ತದೆ. ಸಂಸ್ಕರಣಾ ಕ್ಷೇತ್ರ "RNG ಇನಿಶಿಯಲೈಸೇಶನ್ ಸಂಖ್ಯೆ" ಅನ್ನು 0 ಗೆ ಹೊಂದಿಸಿದಾಗ, ಸಂಖ್ಯೆಗಳ ಅನುಕ್ರಮವನ್ನು ರಚಿಸುವಾಗ ಹುಸಿ-ಯಾದೃಚ್ಛಿಕ ಆರಂಭವು ಸಂಭವಿಸುತ್ತದೆ.

ಜನರೇಟರ್ನ ವೇಗವು ಉತ್ತಮವಾಗಿದೆ, ಉದಾಹರಣೆಗೆ, 100,000 ಸಂಖ್ಯೆಗಳನ್ನು 0.5 ಸೆಕೆಂಡುಗಳಿಗಿಂತ ಕಡಿಮೆ ಅವಧಿಯಲ್ಲಿ ರಚಿಸಲಾಗಿದೆ.

ರಾಕ್, ಪೇಪರ್, ಕತ್ತರಿ ಆಟದ ಉದಾಹರಣೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಸಣ್ಣ ಶ್ರೇಣಿಯ ಸಂಖ್ಯೆಗಳಲ್ಲಿ RNG ಅನ್ನು ಬಳಸುವ ಉದಾಹರಣೆಯನ್ನು ನಾನು ತೋರಿಸುತ್ತೇನೆ.

ನಿಯಮಗಳು ಸರಳವಾಗಿದೆ: ಇಬ್ಬರು ಆಟಗಾರರು ಸೂಚಿಸಿದ ವಸ್ತುಗಳನ್ನು ಸನ್ನೆಗಳೊಂದಿಗೆ ತೋರಿಸುತ್ತಾರೆ. ಈ ಸಮಯದಲ್ಲಿ ಯಾರು ಬಲವಾದ ವ್ಯಕ್ತಿತ್ವವನ್ನು ಹೊಂದಿದ್ದಾರೆಯೋ ಅವರು ಗೆಲ್ಲುತ್ತಾರೆ.

ರಾಕ್ ಕತ್ತರಿಗಳನ್ನು ಸೋಲಿಸುತ್ತಾನೆ.

ಕತ್ತರಿ ಕಾಗದವನ್ನು ಹೊಡೆಯುತ್ತದೆ.

ಪೇಪರ್ ಸ್ಟೋನ್ ಅನ್ನು ಸೋಲಿಸುತ್ತದೆ.

ಈ ಆಯ್ಕೆಯಲ್ಲಿ, ಎಲ್ಲವೂ ಸಮಾನವಾಗಿರುತ್ತದೆ ಮತ್ತು ಗೆಲ್ಲುವ ಸಾಧ್ಯತೆಗಳು ಒಂದೇ ಆಗಿರುತ್ತವೆ.

99 ಆಟಗಳನ್ನು ಆಡಿದ ನಂತರ, ನಾನು ಪ್ರತಿ ಚಿತ್ರದಲ್ಲಿ ಒಂದೇ ಸಂಖ್ಯೆಯ ಕ್ಲಿಕ್‌ಗಳನ್ನು ಮಾಡಿದ್ದೇನೆ, 33 ಬಾರಿ, ಇದನ್ನು ಕೆಳಗಿನ ಬಲ ರೇಖಾಚಿತ್ರದಲ್ಲಿ ಕಾಣಬಹುದು. ಕಂಪ್ಯೂಟರ್ ನನಗಿಂತ ಹೆಚ್ಚಾಗಿ ಗೆದ್ದಿತು, ಅದು ಸ್ವಲ್ಪ ನಿರಾಶಾದಾಯಕವಾಗಿತ್ತು. ಕೆಳಗಿನ ಎಡ ಚಾರ್ಟ್ನಲ್ಲಿ ನೋಡಬಹುದಾದಂತೆ ಕಂಪ್ಯೂಟರ್ ಹೆಚ್ಚಾಗಿ ಕಾಗದವನ್ನು ಬಳಸುತ್ತದೆ. ಮಧ್ಯದಲ್ಲಿರುವ ಗ್ರಾಫ್ ನಾನು ವಿಜೇತನಲ್ಲ ಎಂದು ತೋರಿಸುತ್ತದೆ. ಕಂಪ್ಯೂಟರ್‌ನ ಗೆಲುವಿನ ಕೆಂಪು ಗ್ರಾಫ್ ಹಸಿರು (ನನ್ನ ಗೆಲುವುಗಳು) ಗಿಂತ ಹೆಚ್ಚಾಗಿರುತ್ತದೆ.

ನಿಮ್ಮ ಅದೃಷ್ಟವನ್ನು ಪ್ರಯತ್ನಿಸಿ! ತುಣುಕುಗಳು ಬೀಳುವ ಅದೇ ಸಂಭವನೀಯತೆಯ ಹೊರತಾಗಿಯೂ, ಫಲಿತಾಂಶವು ಯಾವಾಗಲೂ ವಿಭಿನ್ನವಾಗಿರುತ್ತದೆ.

ಆಟದ ಅಂಕಿಅಂಶಗಳನ್ನು ಮಧ್ಯದಲ್ಲಿ, ಗುಲಾಬಿ ಅಂಶಗಳ ಗುಂಪಿನಲ್ಲಿ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.

ಮೌಸ್‌ನೊಂದಿಗೆ ಬಟನ್ ಅನ್ನು ಒಮ್ಮೆ ಕ್ಲಿಕ್ ಮಾಡುವುದರ ಮೂಲಕ, ನೀವು ಬಯಸಿದ ಫಿಗರ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಕೀಬೋರ್ಡ್‌ನಲ್ಲಿರುವ ಸಂಖ್ಯೆಗಳನ್ನು (ಹೆಚ್ಚುವರಿ ಒಂದಲ್ಲ) ಬಳಸಬಹುದು. ಕೀಲಿಗಳನ್ನು ಒತ್ತುವ ಮೂಲಕ, ನೀವು ಡೇಟಾವನ್ನು ಸ್ವಲ್ಪ ವೇಗವಾಗಿ ನಮೂದಿಸಬಹುದು, ವಿಶೇಷವಾಗಿ ಅಂಕಿಅಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ನೀವು ಬುದ್ದಿಹೀನ ಆಟಗಳನ್ನು ಆಡಬೇಕಾದರೆ.

ಆಟವನ್ನು ಸಂಕೀರ್ಣಗೊಳಿಸೋಣ. ಕ್ಲಾಸಿಕ್ ಫಿಗರ್‌ಗಳಿಗೆ ವೆಲ್ ಅನ್ನು ಸೇರಿಸೋಣ.

ರಾಕ್ ಕತ್ತರಿಗಳನ್ನು ಸೋಲಿಸುತ್ತಾನೆ.

ಕತ್ತರಿ ಕಾಗದವನ್ನು ಹೊಡೆಯುತ್ತದೆ.

ಕಾಗದವು ರಾಕ್ ಮತ್ತು ವೆಲ್ ಅನ್ನು ಸೋಲಿಸುತ್ತದೆ.

ಚೆನ್ನಾಗಿ ರಾಕ್ ಮತ್ತು ಕತ್ತರಿ ಸೋಲಿಸುತ್ತಾನೆ.

ಈ ರೂಪಾಂತರದಲ್ಲಿ, ತುಣುಕುಗಳ ಅಸಮಾನ ಮೌಲ್ಯವು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಸೈದ್ಧಾಂತಿಕವಾಗಿ, ಪೇಪರ್ ಮತ್ತು ವೆಲ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡುವ ಮೂಲಕ ಗೆಲ್ಲಲು ಹೆಚ್ಚಿನ ಅವಕಾಶಗಳಿವೆ, ಏಕೆಂದರೆ ಅವರ ಆರ್ಸೆನಲ್ನಲ್ಲಿ ಅವರು ಎರಡು ಸಹ ತುಣುಕುಗಳನ್ನು ಸೋಲಿಸಬಹುದು. ಅದನ್ನು ಪ್ರಾಯೋಗಿಕವಾಗಿ ಪರಿಶೀಲಿಸೋಣ:

ನಾನು ಸ್ಟ್ರಾಂಗ್ ಕಾಯಿಗಳ ಮೇಲೆ ಮಾತ್ರ ಕ್ಲಿಕ್ ಮಾಡಿ ಗೆದ್ದೆ. ಸಿದ್ಧಾಂತವು ಅಭ್ಯಾಸದಿಂದ ದೃಢೀಕರಿಸಲ್ಪಟ್ಟಿದೆ.

ದುರ್ಬಲ ತುಣುಕುಗಳ ಮೇಲೆ ಮಾತ್ರ ಕ್ಲಿಕ್ ಮಾಡುವುದರಿಂದ ಫಲಿತಾಂಶಗಳನ್ನು ನೀಡಿತು, ನಾನು ಸೋತಿದ್ದೇನೆ.

ಆಟದ ಇನ್ನೂ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಆವೃತ್ತಿಯು ಐದನೇ ತುಣುಕು, ಫೈರ್‌ನ ಪರಿಚಯವಾಗಿದೆ.

ರಾಕ್ ಕತ್ತರಿಗಳನ್ನು ಸೋಲಿಸುತ್ತಾನೆ ಮತ್ತು ವೆಲ್ ಪೇಪರ್ ಮತ್ತು ಫೈರ್‌ಗೆ ಸೋಲುತ್ತಾನೆ.

ಕತ್ತರಿ ಪೇಪರ್ ಅನ್ನು ಸೋಲಿಸುತ್ತದೆ ಮತ್ತು ಫೈರ್ ರಾಕ್ ಅಂಡ್ ವೆಲ್ ಗೆ ಸೋಲುತ್ತದೆ.

ಕಾಗದವು ರಾಕ್ ಮತ್ತು ವೆಲ್ ಅನ್ನು ಸೋಲಿಸುತ್ತದೆ ಮತ್ತು ಫೈರ್ ಮತ್ತು ಕತ್ತರಿಗಳಿಗೆ ಸೋಲುತ್ತದೆ.

ಫೈರ್ ಅನ್ನು ಸೋಲಿಸುತ್ತದೆ ಮತ್ತು ಕತ್ತರಿ ರಾಕ್ ಮತ್ತು ಪೇಪರ್ಗೆ ಸೋಲುತ್ತದೆ.

ಫೈರ್ ಪೇಪರ್ ಅನ್ನು ಸೋಲಿಸುತ್ತದೆ ಮತ್ತು ರಾಕ್ ಕತ್ತರಿ ಮತ್ತು ಬಾವಿಗೆ ಸೋಲುತ್ತದೆ.

ಈ ರೂಪಾಂತರದಲ್ಲಿ, ತುಣುಕುಗಳು ಸಮಾನವಾಗಿರುತ್ತವೆ, ಆದರೆ ಎರಡು ತುಣುಕುಗಳು ಗೆಲ್ಲುತ್ತವೆ ಮತ್ತು ಕಳೆದುಕೊಳ್ಳುತ್ತವೆ, ಇದು ಕೆಲವು ಒಳಸಂಚುಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ ಮತ್ತು ಡ್ರಾಗಳ ಸಾಧ್ಯತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.

ನನ್ನ ಕ್ಲಿಕ್‌ಗಳು ಅಸ್ತವ್ಯಸ್ತವಾಗಿದ್ದವು ಮತ್ತು ಕಂಪ್ಯೂಟರ್ ಮತ್ತೆ ನನ್ನನ್ನು ಸೋಲಿಸಿತು. ಆಟದ ಸಮಯದಲ್ಲಿ, ಈ ಮಾಹಿತಿಯನ್ನು ಆಧರಿಸಿ ಕಂಪ್ಯೂಟರ್ ಯಾವ ಭಾಗವನ್ನು ಹೆಚ್ಚಾಗಿ ಬಳಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೀವು ನೋಡಬಹುದು, ನೀವು ಅಸ್ತವ್ಯಸ್ತವಾಗಿ ಆಡಲು ಪ್ರಯತ್ನಿಸಬಹುದು, ಆದರೆ ಚಿಂತನಶೀಲವಾಗಿ ಮತ್ತು ಪ್ರಾಯಶಃ ನಿಮ್ಮ ಯಶಸ್ಸಿನ ಸಾಧ್ಯತೆಗಳನ್ನು ಹೆಚ್ಚಿಸಬಹುದು.

ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಯ ಜನರೇಟರ್ ಅನ್ನು ಹೊಂದಿಸುವುದು ತನ್ನದೇ ಆದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿದೆ. "ಬಳಕೆದಾರರ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಬಳಸಬೇಡಿ" ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ತೆರವುಗೊಳಿಸಿದಾಗ, RNG ಅನ್ನು ಪ್ರಾರಂಭಿಸುವಾಗ ಆಟಗಾರನಿಂದ ಒತ್ತಿದ ಕೀಲಿಯ ಸಂಖ್ಯೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಇದು ಪೀಳಿಗೆಗೆ ಯಾದೃಚ್ಛಿಕತೆಯನ್ನು ಸೇರಿಸುತ್ತದೆ. ಮನುಷ್ಯ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳ ಅತ್ಯುತ್ತಮ ಜನರೇಟರ್, ಆದರೆ ಇನ್ನೂ ಮೆದುಳು ಸಹ ಹುಸಿ ಅನುಕ್ರಮಗಳನ್ನು ಹೊಂದಿದೆ. ಒಬ್ಬ ವ್ಯಕ್ತಿಯನ್ನು 100 ಕೀ ಪ್ರೆಸ್‌ಗಳನ್ನು ಮಾಡಲು ನೀವು ಒತ್ತಾಯಿಸಿದರೆ, ಈ ವಿಧಾನವನ್ನು ಆತ್ಮಸಾಕ್ಷಿಯಾಗಿ ನಿರ್ವಹಿಸಬಹುದು, ಸಾಧ್ಯವಾದಷ್ಟು ವಿಭಿನ್ನ ಕೀಗಳನ್ನು ಒತ್ತುವ ಮೂಲಕ ಅಥವಾ ಕೇವಲ ಒಂದು ಗುಂಡಿಯನ್ನು ಒತ್ತುವ ಮೂಲಕ ಅದನ್ನು ಅಜಾಗರೂಕತೆಯಿಂದ ಮಾಡಬಹುದು. ಈ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಹೊಂದಿಸಿದಾಗ, ಕಂಪ್ಯೂಟರ್ ಷಫಲಿಂಗ್ ಮಾತ್ರ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ವ್ಯಕ್ತಿಯಿಂದ ಯಾದೃಚ್ಛಿಕ ಅನುಕ್ರಮವನ್ನು ಸ್ವೀಕರಿಸುವಾಗ, ಉದಾಹರಣೆಗೆ, ಎಲೆಕ್ಟ್ರಾನಿಕ್ ಸಿಗ್ನೇಚರ್ ಕೀಲಿಯನ್ನು ರಚಿಸಲು, ಒತ್ತಿದ ಕೀಲಿಯನ್ನು ಮಾತ್ರವಲ್ಲದೆ ಪ್ರೆಸ್ಗಳ ನಡುವಿನ ಮಧ್ಯಂತರವನ್ನೂ ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳುವುದು ಸೂಕ್ತವಾಗಿದೆ. ಇದು ಬಹಳ ಯಾದೃಚ್ಛಿಕ ಮಾಹಿತಿಯಾಗಿದೆ, ಆದರೂ ಒಬ್ಬ ಉತ್ತಮ ಸಂಗೀತಗಾರ ಅದೇ ಅನುಕ್ರಮವನ್ನು ಹಲವಾರು ಬಾರಿ ರಚಿಸಬಹುದು.

"RNG ಇನಿಶಿಯಲೈಸೇಶನ್ ಬಳಸಬೇಡಿ" ಫ್ಲ್ಯಾಗ್ ಇನಿಶಿಯಲೈಸೇಶನ್ ಮೋಡ್ ಅನ್ನು ಆನ್/ಆಫ್ ಮಾಡುತ್ತದೆ. ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆ ಜನರೇಟರ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸುವಾಗ ನೀವು ಪ್ರಾರಂಭವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದರೆ, ನಾನು ಅರ್ಥಮಾಡಿಕೊಂಡಂತೆ ಒಂದು ಮಿಶ್ರ ಅನುಕ್ರಮವನ್ನು ರಚಿಸಲಾಗಿದೆ, ಇದು ನನಗೆ ಸಾಕಷ್ಟು ಪರಿಣಾಮಕಾರಿ ಎಂದು ತೋರುತ್ತದೆ.

RNG = NewRandomNumberGenerator();

ಅಲ್ಲದೆ, ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವಾಗ, ನಿಮ್ಮ ಸ್ವಂತ ಆರಂಭದ ಸಂಖ್ಯೆಯನ್ನು ನೀವು ಹೊಂದಿಸಬಹುದು, ನಂತರ ಅದೇ ಸಂಖ್ಯೆಯನ್ನು ಊಹಿಸಲು ರಚಿಸಲಾಗುತ್ತದೆ.

ಗೆಲುವುಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ವಿಧಾನವನ್ನು ಬರೆಯುವಾಗ, ಫಲಿತಾಂಶವನ್ನು ವಿವರಿಸುವ ಸಮಸ್ಯೆಯನ್ನು ನಾನು ಎದುರಿಸಿದೆ, ವಿಶೇಷವಾಗಿ ಐದು ಅಂಕಿಗಳನ್ನು ಹೊಂದಿರುವ ಆಟಕ್ಕೆ. ಅದನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಿದ ನಂತರ, ಹಲವಾರು ಅಕ್ಷರಗಳು ಇರುತ್ತವೆ ಎಂದು ನಾನು ಅರಿತುಕೊಂಡೆ, ಏಕೆಂದರೆ ಹಲವು ಆಕಾರಗಳೊಂದಿಗೆ ಹಲವು ಆಯ್ಕೆಗಳಿವೆ. ಮೂರು ಅಂಕಿಗಳೊಂದಿಗೆ ನಾವು ಗರಿಷ್ಠ 9 ಆಯ್ಕೆಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ, ನಾಲ್ಕು 16 ಆಯ್ಕೆಗಳೊಂದಿಗೆ ಮತ್ತು ಐದು 25 ಆಯ್ಕೆಗಳೊಂದಿಗೆ ಕಾಂಬಿನೇಟೋರಿಕ್ಸ್ ನಮಗೆ ಹೇಳುತ್ತದೆ. ಡ್ರಾಗಳನ್ನು ತಿರಸ್ಕರಿಸುವುದು, ಅದೇ ಅಂಕಿಅಂಶವನ್ನು ಆರಿಸಿದಾಗ, ನಾನು 19 ಷರತ್ತುಗಳ ರೂಪಾಂತರಗಳನ್ನು ಬರೆಯಬೇಕಾಗಿದೆ ಎಂದು ನಾನು ಅರಿತುಕೊಂಡೆ.

ನಾನು ಅದರ ಬಗ್ಗೆ ಯೋಚಿಸಿದೆ, ಏಕೆಂದರೆ ಇದು ನಿಸ್ಸಂಶಯವಾಗಿ ಕಳಪೆ ಓದಬಲ್ಲ ಕೋಡ್‌ಗೆ ಕಾರಣವಾಗುತ್ತದೆ ಮತ್ತು ನಾನು ಸುಂದರವಾದ ಪರಿಹಾರವೆಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ಒಟ್ಟು 9 ಷರತ್ತುಗಳೊಂದಿಗೆ.

ರೆಸ್ = ಪ್ಲೇಯರ್ - ಕಾಂಪ್; SettingsOption = 3 ಆಗಿದ್ದರೆ (Res = -1) ಅಥವಾ (Res = 2) ನಂತರ 1 ಹಿಂತಿರುಗಿ; //ವಿನ್ ಇಲ್ಲದಿದ್ದರೆ ರಿಟರ್ನ್ 2; //ಸೋಲು ಎಂಡಿಫ್; ElseIfSettingsOption = 4 ನಂತರ (Res = -1) ಅಥವಾ (Res = 2) ಅಥವಾ (Res = 3) ನಂತರ 1 ಹಿಂತಿರುಗಿ; //ವಿನ್ ಇಲ್ಲದಿದ್ದರೆ ರಿಟರ್ನ್ 2; //ಸೋಲು ಎಂಡಿಫ್; ಇಲ್ಲದಿದ್ದರೆ ಸೆಟ್ಟಿಂಗ್‌ಗಳ ಆಯ್ಕೆ = 5 ನಂತರ (ರೆಸ್ = -1) ಅಥವಾ (ರೆಸ್ = 2) ಅಥವಾ (ರೆಸ್ = -3) ಅಥವಾ (ರೆಸ್ = 4) ನಂತರ 1 ಅನ್ನು ಹಿಂತಿರುಗಿ; //ವಿನ್ ಇಲ್ಲದಿದ್ದರೆ ರಿಟರ್ನ್ 2; //ಸೋಲು ಎಂಡಿಫ್; ಕೊನೆಯಲ್ಲಿ ವೇಳೆ;

ಕಾಂಪ್ಯಾಕ್ಟ್, ಸ್ಪಷ್ಟ, ಸಂಪಾದಿಸಲು ಸುಲಭ.

ಪ್ರತಿ ಅಂಕಿ ತನ್ನದೇ ಆದ ಸಂಖ್ಯೆಯನ್ನು ಹೊಂದಿದೆ ಎಂದು ನಾನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಿದ್ದೇನೆ: 1 - ಕಲ್ಲು, 2 - ಕತ್ತರಿ, 3 - ಪೇಪರ್, 4 - ಸರಿ, 5 - ಬೆಂಕಿ. ಆಟದ ಪರಿಣಾಮವಾಗಿ, ನಾನು ತುಣುಕುಗಳ ಸಂಖ್ಯೆಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಲೆಕ್ಕ ಹಾಕುತ್ತೇನೆ ಮತ್ತು ಈ ವ್ಯತ್ಯಾಸವು ಯಾರು ಗೆದ್ದಿದ್ದಾರೆ ಎಂಬ ಪ್ರಶ್ನೆಗೆ ನನಗೆ ಸ್ಪಷ್ಟ ಉತ್ತರವನ್ನು ನೀಡುತ್ತದೆ.

ನಿರ್ವಹಿಸಲಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಯಾದೃಚ್ಛಿಕ ಅನುಕ್ರಮಗಳ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಅನ್ವೇಷಿಸಲು ಸಹಾಯ ಮಾಡುವ ಸಂಸ್ಕರಣೆ ಮತ್ತು ಸಂರಚನೆಯನ್ನು ಉಲ್ಲೇಖಿಸದೆ ಬರೆಯಲಾಗುತ್ತದೆ. ತೆಳುವಾದ ಕ್ಲೈಂಟ್‌ನಲ್ಲಿ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ 8.3.10, 8.3.11 ನಲ್ಲಿ ಪರೀಕ್ಷಿಸಲಾಗಿದೆ.

ಈ ಲೇಖನದೊಂದಿಗೆ ನಾನು ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಯ ಅನುಕ್ರಮಗಳನ್ನು ಉತ್ಪಾದಿಸುವ ಪ್ರಾಮುಖ್ಯತೆ ಮತ್ತು ಗಂಭೀರತೆಯನ್ನು ತಿಳಿಸಲು ಆಶಿಸಿದ್ದೇನೆ.

  21
 //ಫಂಕ್ಷನ್ ಮೌಲ್ಯಗಳ ಸುಲಭವಾಗಿ ಓದಲು ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. // ಸಂಖ್ಯೆಯ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಉದಾಹರಣೆಗಳು ValueFormat = ಸ್ವರೂಪ(123456.789, "NRT=10; NRT=2"); //ValueFormat = "123,456.79"ValueFormat = ಸ್ವರೂಪ(123456.789, "HH=0; NHV=2"); //ಮೌಲ್ಯ   16
 ಪೂರ್ಣ-ಪಠ್ಯ ಹುಡುಕಾಟ - ಬಳಸಿದ ಸಂರಚನೆಯಲ್ಲಿ ಎಲ್ಲಿಯಾದರೂ ಪಠ್ಯ ಮಾಹಿತಿಯನ್ನು ಹುಡುಕಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ಸಂಪೂರ್ಣ ಸಂರಚನೆಯ ಉದ್ದಕ್ಕೂ ಅಥವಾ ಸಂಕುಚಿತಗೊಳಿಸುವ ಮೂಲಕ ಅಗತ್ಯ ಡೇಟಾವನ್ನು ಹುಡುಕಬಹುದು ...   8
 "ಪಾಯಿಂಟ್ ಇನ್ ಟೈಮ್" ಒಂದು ವರ್ಚುವಲ್ ಕ್ಷೇತ್ರವಾಗಿದೆ, ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿಲ್ಲ. ಪಾಯಿಂಟ್ ಇನ್ ಟೈಮ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಒಳಗೊಂಡಿದೆ (ಇದು ದಿನಾಂಕ ಮತ್ತು ಡಾಕ್ಯುಮೆಂಟ್‌ಗೆ ಲಿಂಕ್ ಅನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ) 7.7 ರಲ್ಲಿ ಡಾಕ್ಯುಮೆಂಟ್ ಸ್ಥಾನದ ಪರಿಕಲ್ಪನೆ ಇತ್ತು ಮತ್ತು 8.x ಪಾಯಿಂಟ್ ಇನ್ ಟೈಮ್ ನಲ್ಲಿ ಪಡೆಯಲು...   6
 8.x FindByLinks (FindDataByRef) ಸಿಂಟ್ಯಾಕ್ಸ್: FindByLinks (ಲಿಸ್ಟ್‌ಗಳ ಲಿಂಕ್‌ಗಳು) ನಿಯತಾಂಕಗಳು: ಲಿಂಕ್‌ಗಳ ಪಟ್ಟಿ ಅಗತ್ಯವಿರುವ ಪ್ರಕಾರ: ಅರೇ. ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ಲಿಂಕ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿರುವ ಒಂದು ಶ್ರೇಣಿಯು ಅದರ ಲಿಂಕ್‌ಗಳನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕು. ...

ಇದು 1C ಯಲ್ಲಿ ಉಪಯುಕ್ತ ಎಂದು ನಾನು ಭಾವಿಸಲಿಲ್ಲ, ಆದರೆ ಇಲ್ಲಿ ನೀವು... ಕ್ಲೈಂಟ್‌ಗಳು "ಕ್ಯಾಪ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಿ" ನಂತಹ ಪ್ರಚಾರವನ್ನು ನಡೆಸಲು ನಿರ್ಧರಿಸಿದ್ದಾರೆ, ನೀವು ಮಾತ್ರ ಪದಗಳನ್ನು ಸಂಗ್ರಹಿಸಬೇಕು, ಯಾರು ಅವರ ಸೆಟ್‌ನಿಂದ ಸರಿಯಾದ ಪದವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತಾರೆ ಅಕ್ಷರಗಳು ಗೆಲ್ಲುತ್ತವೆ. ಸಾಮಾನ್ಯವಾಗಿ, ಕಾರ್ಯವು ಸರಳವೆಂದು ತೋರುತ್ತದೆ: ವರ್ಣಮಾಲೆ ಇದೆ, ಒಂದು ನಿರ್ದಿಷ್ಟ ಪದವನ್ನು ಸಂಗ್ರಹಿಸಬೇಕಾಗಿದೆ, ಉದಾಹರಣೆಗೆ "ಕಾಗ್ನ್ಯಾಕ್", ನೀವು ನೋಡುವಂತೆ ಇದು 6 ಅಕ್ಷರಗಳನ್ನು ಹೊಂದಿದೆ.

ನೀವು ಮಾಡಬೇಕಾದುದು: ವರ್ಣಮಾಲೆಯ ಯಾವುದೇ ಅಕ್ಷರಗಳಿಂದ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಯಾದೃಚ್ಛಿಕ ಆರು-ಅಕ್ಷರದ ಸಂಯೋಜನೆಗಳನ್ನು ರಚಿಸಿ, ಇದಕ್ಕೆ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಆಯ್ಕೆಗಳನ್ನು ಸೇರಿಸಿ, ಇದರಲ್ಲಿ ಪದವನ್ನು ಇನ್ನೂ ಸೇರಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ, "nkkoya" - ಪದವು ರೂಪುಗೊಂಡಿದೆ, ಆದರೆ "ಕಾವ್ರಿ" ಸ್ಪಷ್ಟವಾಗಿ ಸೂಕ್ತವಲ್ಲ.

ಹೆಚ್ಚುವರಿ ಷರತ್ತು: ಈ ಎಲ್ಲಾ ಆಯ್ಕೆಗಳನ್ನು (ಸರಿಯಾದ ಮತ್ತು ಅಲ್ಲ) ಸಂಖ್ಯೆ ಮಾಡಬೇಕು ಆದ್ದರಿಂದ ನೀವು "ಬಹುಮಾನ" ಕಾರ್ಡ್ ಅನ್ನು ಸ್ವೀಕರಿಸಿದಾಗ ನೀವು ಸಂಖ್ಯೆಯನ್ನು ಪರಿಶೀಲಿಸಬಹುದು (ಒಂದು ಇದೆಯೇ).

1C ಗೂ ಇದಕ್ಕೂ ಏನು ಸಂಬಂಧವಿದೆ ಎಂದು ತೋರುತ್ತದೆ? ಆದ್ದರಿಂದ ಅವರು ಲೆಕ್ಕಪರಿಶೋಧಕ ಪ್ರೋಗ್ರಾಂಗೆ ಈ ಕಾರ್ಡ್‌ಗಳು ಮತ್ತು ಬಹುಮಾನಗಳಿಗೆ ಲೆಕ್ಕಪತ್ರವನ್ನು ಸೇರಿಸಲು ಬಯಸುತ್ತಾರೆ ಮತ್ತು ಅದೇ ಸಮಯದಲ್ಲಿ ಅವರು ಯಾದೃಚ್ಛಿಕ ಸಂಯೋಜನೆಗಳನ್ನು ರಚಿಸಲು ಕೇಳಿದರು (ಅಲ್ಲದೆ, ಅವುಗಳನ್ನು ಕೈಯಾರೆ ಸಂಯೋಜಿಸಬಾರದು).
ಪ್ರತಿ ಪ್ರಚಾರಕ್ಕಾಗಿ, ಸಂಯೋಜನೆಗಳನ್ನು ಒಮ್ಮೆ ರಚಿಸಲಾಗುತ್ತದೆ, ನಂತರ ಕಾರ್ಡ್ಗಳನ್ನು ಅವುಗಳ ಆಧಾರದ ಮೇಲೆ ತಯಾರಿಸಲಾಗುತ್ತದೆ, ಅಂದರೆ. ಮುಂದಿನ ಬಾರಿ ಪದವು ವಿಭಿನ್ನವಾಗಿರುತ್ತದೆ, ಇತ್ಯಾದಿ.

ಸಾಮಾನ್ಯವಾಗಿ, ಕಾರ್ಯವು ಈ ಕೆಳಗಿನವುಗಳಿಗೆ ಕುದಿಯುತ್ತದೆ:
1. ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳನ್ನು ರಚಿಸಿ, ಮೇಲಾಗಿ ದೊಡ್ಡ ಹರಡುವಿಕೆಯೊಂದಿಗೆ.
2. ಸಂಖ್ಯೆಯನ್ನು ಬಳಸಿ, ಅಕ್ಷರಗಳ ಸಂಯೋಜನೆಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಿ (ಅಂದರೆ, ಸಂಭವನೀಯ ಸಂಯೋಜನೆಗಳು ಮತ್ತು ಅವುಗಳ ಸಂಖ್ಯೆಗಳ ನಡುವೆ ಕೆಲವು ಪತ್ರವ್ಯವಹಾರಗಳನ್ನು ಕಂಡುಹಿಡಿಯಿರಿ).
3. ಹಿಂದಿನದಕ್ಕೆ ವಿರುದ್ಧವಾದ ಬಿಂದು - ಪದದ ಮೂಲಕ ಸಂಯೋಜನೆಯ ಸಂಖ್ಯೆಯನ್ನು ಪರಿಶೀಲಿಸಿ.

ಪರಿಹಾರ:
1. ಏಕೆಂದರೆ avb ಮತ್ತು NS ನಿಂದ ಜನರೇಟರ್ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳ ಸಣ್ಣ ಹರಡುವಿಕೆಯನ್ನು ನೀಡಿತು, ನಾನು ಸ್ವಲ್ಪ ವಿಭಿನ್ನ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಬಳಸಬೇಕಾಗಿತ್ತು:

ಫಂಕ್ಷನ್ ರಾಂಡಮ್() ಖಾಲಿ ಮೌಲ್ಯ (ರ್ಯಾಂಡ್‌ಸೀಡ್) = 1 ಆಗಿದ್ದರೆ ರಾಂಡ್‌ಸೀಡ್ = _ಗೆಟ್‌ಪರ್ಫಾರ್ಮೆನ್ಸ್‌ಕೌಂಟರ್ (); endif; randSeed=(a*randSeed+c)%m; ರಾಂಡ್ ಸೀಡ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ; ಅಂತ್ಯಕ್ರಿಯೆ

ಇಲ್ಲಿ:
a=1664525; c=1013904223; ಮೀ=4294967296;
ಕೊನೆಯ ವೇರಿಯಬಲ್ 2 ರಿಂದ 32 ನೇ ಶಕ್ತಿ, ಇತರ ಎರಡು ಅಂತಹ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಶಿಫಾರಸು ಮಾಡಲಾದ ಗುಣಾಂಕಗಳಾಗಿವೆ

ಗರಿಷ್ಟ ಸಂಖ್ಯೆಯ ಸಂಯೋಜನೆಗಳ ಆಧಾರದ ಮೇಲೆ 2^32 ರ ಗರಿಷ್ಠ ಮೌಲ್ಯದ ಮಿತಿಯನ್ನು ಆಯ್ಕೆ ಮಾಡಲಾಗಿದೆ (28 ಅಕ್ಷರಗಳು ಮತ್ತು ಪ್ರತಿ 7 ಪದಗಳ ಟ್ರಿಮ್ ಮಾಡಿದ ವರ್ಣಮಾಲೆಗೆ, ನೈಜ ಸಮಸ್ಯೆಯಲ್ಲಿ ನಿಖರವಾಗಿ 7 ಇರುವುದರಿಂದ, ಒಟ್ಟು ಸಂಯೋಜನೆಗಳ ಸಂಖ್ಯೆ 28 ಆಗಿರುತ್ತದೆ. ^7, ಹೀಗೆ ಆಯ್ದ ಮಿತಿಯು ಮಧ್ಯಂತರದ ಮಧ್ಯಭಾಗದಲ್ಲಿರುತ್ತದೆ, ಇದು 20-30 ಸಾವಿರ ಆಯ್ಕೆಗಳ ಮಾದರಿಗೆ ಸಾಕಷ್ಟು ಸಾಕು)

ನಮಗೆ ಇನ್ನೂ ಒಂದು ಸಹಾಯಕ ಕಾರ್ಯದ ಅಗತ್ಯವಿದೆ - ಧನಾತ್ಮಕ ಪೂರ್ಣಾಂಕ ಶಕ್ತಿಗೆ ಏರಿಸುವುದು:

ಫಂಕ್ಷನ್ ಪದವಿ(ಮೌಲ್ಯ a, ಮೌಲ್ಯ b, Res=1) b>0 ಆಗಿದ್ದರೆ Res=Res*a; b=b-1; ಪದವಿ(a,b,Res); ರಿಟರ್ನ್ ರೆಸ್; ಇಲ್ಲದಿದ್ದರೆ ರಿಟರ್ನ್ ರೆಸ್; ಕೊನೆಯಲ್ಲಿ ವೇಳೆ; ಅಂತ್ಯಕ್ರಿಯೆ

ಇಲ್ಲಿ: a - ಪದವಿಯ ಆಧಾರ, b - ಘಾತ, Res - ಫಲಿತಾಂಶ

2. ಅನುಕ್ರಮ ಸಂಯೋಜನೆಗಳ ನಡುವಿನ ಸಂಬಂಧವನ್ನು ಗುರುತಿಸುವುದು ಆಶ್ಚರ್ಯಕರವಾಗಿ ಸರಳವಾಗಿದೆ:

ಹಲವಾರು ಅಂಶಗಳನ್ನು ಕ್ರಮವಾಗಿ ಜೋಡಿಸಿದ ನಂತರ, ಸಂಖ್ಯಾ ವ್ಯವಸ್ಥೆಯೊಂದಿಗೆ ಚಿಹ್ನೆಗಳ ಜೋಡಣೆಯ ಹೋಲಿಕೆಯನ್ನು ನಾನು ಬಹಿರಂಗಪಡಿಸಿದೆ, ದಶಮಾಂಶವಲ್ಲ, ಆದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ “ಹೆಕ್ಸಾಡೆಸಿಮಲ್” (ಪರಿಣಾಮವಾಗಿ “ಪದ” ದಲ್ಲಿನ ಅಕ್ಷರಗಳ ಸಂಖ್ಯೆಯಿಂದ).
ಹೀಗಾಗಿ, ಅದರ ಸಂಖ್ಯೆಯಿಂದ ಸಂಯೋಜನೆಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು, ಅದರ ಸಂಖ್ಯೆಯನ್ನು ಈ ಸಂಖ್ಯೆಯ ವ್ಯವಸ್ಥೆಗೆ ಪರಿವರ್ತಿಸುವುದು ಅಗತ್ಯವಾಗಿತ್ತು.

ನಮ್ಮ ಸಂಖ್ಯಾ ವ್ಯವಸ್ಥೆಗೆ, ಆಧಾರವು ಆರು ಶಕ್ತಿಗಳಾಗಿರುತ್ತದೆ, ಅಂದರೆ. ಎಡಭಾಗದಲ್ಲಿರುವ ಮೊದಲ ಅಂಕಿಯನ್ನು ಪಡೆಯಲು, ನೀವು ನಮ್ಮ ಸಂಯೋಜನೆಯ ಸಂಖ್ಯೆಯನ್ನು 6 ರಿಂದ 5 ನೇ ಶಕ್ತಿಗೆ ಭಾಗಿಸಬೇಕು, ನಂತರ ವಿಭಜನೆಯ ಉಳಿದ ಭಾಗವನ್ನು 6 ರಿಂದ 4 ನೇ ಶಕ್ತಿ, ಇತ್ಯಾದಿ.

ಹೀಗಾಗಿ, ನಾವು ಆರು ಸಂಖ್ಯೆಗಳ ಗುಂಪನ್ನು ಪಡೆಯುತ್ತೇವೆ, ಅವುಗಳು ಮೂಲಭೂತವಾಗಿ ನಮ್ಮ ವರ್ಣಮಾಲೆಯಲ್ಲಿ ಅಕ್ಷರಗಳ ಸರಣಿ ಸಂಖ್ಯೆಗಳಾಗಿವೆ.

ಪರಿಣಾಮವಾಗಿ ಕೋಡ್:

ಫಂಕ್ಷನ್ GetCharacters(Pos,TechChar=1 ,SymStr="") TechChar ಆಗಿದ್ದರೆ<к Тогда Делитель=Степень(СтрДлина(Буквы),к-ТекСимв); ТекОст=Поз%Делитель; СимСтр=Строка(СимСтр)+Сред(Буквы,Цел(Поз/Делитель+?(ТекОст>0 ,1 ,0 )),1 ); GetSymbols(TekOst,TekSymv+1,SymStr); SimStr ಹಿಂತಿರುಗಿ; ಇಲ್ಲದಿದ್ದರೆ SimStr=SimStr+Average(Letters,(?(Pos=0 ,StrLength(Letters),Pos)),1 ); SimStr ಹಿಂತಿರುಗಿ; ಕೊನೆಯಲ್ಲಿ ವೇಳೆ; ಅಂತ್ಯಕ್ರಿಯೆ

ಇಲ್ಲಿ:
ಪೋಸ್ - ಸಂಯೋಜನೆ ಸಂಖ್ಯೆ (ಸೂಡೋರಾಂಡಮ್ ಸಂಖ್ಯೆ)
TechSym - ಪ್ರಸ್ತುತ ಚಿಹ್ನೆಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತಿದೆ
SimStr - ಅಕ್ಷರಗಳ ಪರಿಣಾಮವಾಗಿ ಸ್ಟ್ರಿಂಗ್
ಅಕ್ಷರಗಳು = ಪ್ರಮಾಣಿತ ಕ್ರಮದಲ್ಲಿ ವರ್ಣಮಾಲೆಯ ಅಕ್ಷರಗಳನ್ನು ಹೊಂದಿರುವ ಸ್ಟ್ರಿಂಗ್ ("abv...yuya")
k - ಹುಡುಕಾಟ ಪದದಲ್ಲಿನ ಅಕ್ಷರಗಳ ಸಂಖ್ಯೆ (ಈ ಸಂದರ್ಭದಲ್ಲಿ = 6)

3. ಹಿಮ್ಮುಖ ರೂಪಾಂತರವು ಸಹ ಕ್ಷುಲ್ಲಕವಾಗಿದೆ:

ಫಂಕ್ಷನ್ ಗೆಟ್‌ಕಾಂಬಿನೇಶನ್(ಪದ, ಟೆಕ್‌ಕ್ಯಾರೆಕ್ಟರ್=0 , ಪೋಸ್=0 ) ನಾಮಕ್ಯಾರೆಕ್ಟರ್=ಹುಡುಕಿ(ಅಕ್ಷರಗಳು, ಮಧ್ಯಮ(ಪದ, ಟೆಕ್‌ಕ್ಯಾರೆಕ್ಟರ್, 1)); TechCym>0 ಆಗಿದ್ದರೆ TechSym ಆಗಿದ್ದರೆ<к Тогда Поз=Поз+(НомСимв-1 )*Степень(СтрДлина(Буквы),ТекСимв); ПолучитьКомбинацию(Слово,ТекСимв+1 ,Поз); Иначе Возврат Поз; КонецЕсли; Иначе Поз=?(НомСимв=СтрДлина(Буквы),0 ,НомСимв); ПолучитьКомбинацию(Слово,ТекСимв+1 ,Поз); Возврат Поз; КонецЕсли; КонецФункции

ಇಲ್ಲಿ:
ಪದವು ನಾವು ಹುಡುಕುತ್ತಿರುವ ಅಕ್ಷರಗಳ ಸಂಯೋಜನೆಯಾಗಿದೆ
TekSymv - ಪ್ರಸ್ತುತ ಸಂಕೇತವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತಿದೆ (ಮೂಲಭೂತವಾಗಿ ಹೆಕ್ಸಾಡೆಸಿಮಲ್ "ಸಂಖ್ಯೆ" ನ ಅಂಕೆ)
ಪೋಸ್ - ಬಯಸಿದ ಸಂಯೋಜನೆ ಸಂಖ್ಯೆ

N ಸಂಖ್ಯೆಗಳನ್ನು ಮಿಶ್ರಣ ಮಾಡಿ:

ಫಾರ್ a=1 ಮೂಲಕ N ಲೂಪ್ ಅರೇ[a]=a; ಚಕ್ರದ ಅಂತ್ಯ; a=1 ರಿಂದ N-1 ಚಕ್ರಕ್ಕೆ Cl=Case(a,N); // ಮಧ್ಯಂತರದಲ್ಲಿ ಪೂರ್ಣಾಂಕ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆ [a..N]ಕೆ=ಅರೇ[a]; ಅರೇ[a]=ಅರೇ[Sl]; ರಚನೆ[Sl]=K; ಎಂಡ್ಸೈಕಲ್;

Sc = CreateObject("MSScriptControl.ScriptControl "); Sc.language = "VBscript"; sc.executeStatement("ಯಾದೃಚ್ಛಿಕಗೊಳಿಸು"); ಅದು ಇಲ್ಲಿ ಇರುತ್ತದೆ = Sc.eval("rnd ");

1 ರಿಂದ 100 ರವರೆಗೆ ಯಾದೃಚ್ಛಿಕವಾಗಿ ಆಯ್ಕೆ ಮಾಡಲಾದ ಸಂಖ್ಯೆಗಳನ್ನು ನಾನು ಹೇಗೆ ಮಾಡಬಹುದು?

Rand=_GetPerformanceCounter()%(100 +1 );
ಇದು ಅತ್ಯುತ್ತಮವಾಗಿದೆ ಎಂದು ತೋರುತ್ತಿದೆ

ಲೈಬ್ರರಿ ಚಾಪೆ. ಎಸ್ಎಲ್ ಜನರೇಟರ್ ಇರುವಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಸಂಖ್ಯೆಗಳು:
http://1c.proclub.ru/modules/mydownloads/personal.php?cid=92&lid=2688

8.0 ರಲ್ಲಿ, ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳನ್ನು ರಚಿಸಲು ನೀವು ಅಂತರ್ನಿರ್ಮಿತ GUID ಜನರೇಟರ್ ಅನ್ನು ಬಳಸಬಹುದು.
ಸರಳ ಕಾರ್ಯದ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

//ಪೂರ್ಣಾಂಕಗಳಿಗೆ ಮಾತ್ರಫಂಕ್ಷನ್ GetRandomNumber(Min,Max) //Randomize ಬದಲಿಗೆ n = 1 By 100 Cycle Unique = New UniqueIdentifier; ಎಂಡ್ಸೈಕಲ್; //GUID ವಿಶಿಷ್ಟ = AbbrLP (ಹೊಸ ವಿಶಿಷ್ಟ ಗುರುತಿಸುವಿಕೆ); //ಸಂಖ್ಯೆಗಳನ್ನು ಮಾತ್ರ ಇರಿಸಿವಿಶಿಷ್ಟ = StrReplace(ಅನನ್ಯ,"- ",""); ವಿಶಿಷ್ಟ = StrReplace(ಅನನ್ಯ,"a ",""); ವಿಶಿಷ್ಟ = StrReplace(Unique,"b ",""); ವಿಶಿಷ್ಟ = StrReplace(ಅನನ್ಯ,"c ",""); ವಿಶಿಷ್ಟ = StrReplace(ಅನನ್ಯ,"d ",""); ವಿಶಿಷ್ಟ = StrReplace(ಅನನ್ಯ,"e ",""); ವಿಶಿಷ್ಟ = StrReplace(ಅನನ್ಯ,"f ",""); //ಛೇದವು ಒಂದೇ ಸಂಖ್ಯೆಯ ಸೊನ್ನೆಗಳು + 1 ಅನ್ನು ಹೊಂದಿರಬೇಕುಛೇದ = 10 ; n = 2 ಮೂಲಕ (StrLength(StrReplace(Unique,Characters.NPP,""))) ಸೈಕಲ್ ಡಿನೋಮಿನೇಟರ್ = ಛೇದ * 10 ; ಎಂಡ್ಸೈಕಲ್; ಕೇಸ್ = ಸಂಖ್ಯೆ(ಅನನ್ಯ) / ಛೇದ; //ಇಲ್ಲಿ ನಾವು 0 ರಿಂದ 1 ರವರೆಗಿನ ಭಾಗಶಃ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಯನ್ನು ಪಡೆಯುತ್ತೇವೆ //ಕೊಟ್ಟಿರುವ ಮಧ್ಯಂತರದಿಂದ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗೆ ಪರಿವರ್ತಿಸಿ, ಸುತ್ತಿನಲ್ಲಿ ಹತ್ತಿರದ ಪೂರ್ಣಾಂಕಕ್ಕೆಮಧ್ಯಂತರ ಸಂಖ್ಯೆ = ಕನಿಷ್ಠ(ಗರಿಷ್ಠ(Ab(Min + (Max-Min)*Rand),Min),Max); ಮಧ್ಯಂತರದಿಂದ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸಿ; ಅಂತ್ಯಕ್ರಿಯೆ

ಮತ್ತೊಂದು ಸಿಸ್ಟಮ್ ಆಯ್ಕೆ:
Rnd = CreateObject("System.Random"); ವರದಿ(Rnd.Next());

ಕೀವರ್ಡ್ಗಳು: ಜನರೇಟರ್, ಯಾದೃಚ್ಛಿಕ, ಸಂಖ್ಯೆಗಳು, ಸಂಖ್ಯೆ, ಅಲ್ಗಾರಿದಮ್, ಯಾದೃಚ್ಛಿಕ, ಯಾದೃಚ್ಛಿಕ, ವಿತರಣೆ, ಸಮವಸ್ತ್ರ, ಲಾಟರಿ

ಇದು 1C ಯಲ್ಲಿ ಉಪಯುಕ್ತ ಎಂದು ನಾನು ಭಾವಿಸಲಿಲ್ಲ, ಆದರೆ ನಿಮಗಾಗಿ ... ಕ್ಲೈಂಟ್‌ಗಳು “ಕ್ಯಾಪ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಿ” ನಂತಹ ಪ್ರಚಾರವನ್ನು ನಡೆಸಲು ನಿರ್ಧರಿಸಿದ್ದಾರೆ, ನೀವು ಮಾತ್ರ ಪದಗಳನ್ನು ಸಂಗ್ರಹಿಸಬೇಕು, ಯಾರು ಅವರ ಅಕ್ಷರಗಳ ಗುಂಪಿನಿಂದ ಸರಿಯಾದ ಪದವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತಾರೆ ಗೆಲ್ಲುತ್ತಾನೆ. ಸಾಮಾನ್ಯವಾಗಿ, ಕಾರ್ಯವು ಸರಳವೆಂದು ತೋರುತ್ತದೆ: ವರ್ಣಮಾಲೆ ಇದೆ, ಒಂದು ನಿರ್ದಿಷ್ಟ ಪದವನ್ನು ಸಂಗ್ರಹಿಸಬೇಕಾಗಿದೆ, ಉದಾಹರಣೆಗೆ "ಕಾಗ್ನ್ಯಾಕ್", ನೀವು ನೋಡುವಂತೆ ಇದು 6 ಅಕ್ಷರಗಳನ್ನು ಹೊಂದಿದೆ.

ನೀವು ಮಾಡಬೇಕಾದುದು: ವರ್ಣಮಾಲೆಯ ಯಾವುದೇ ಅಕ್ಷರಗಳಿಂದ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಯಾದೃಚ್ಛಿಕ ಆರು-ಅಕ್ಷರದ ಸಂಯೋಜನೆಗಳನ್ನು ರಚಿಸಿ, ಇದಕ್ಕೆ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಆಯ್ಕೆಗಳನ್ನು ಸೇರಿಸಿ, ಇದರಲ್ಲಿ ಪದವನ್ನು ಇನ್ನೂ ಸೇರಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ, "nkkoya" - ಪದವು ರೂಪುಗೊಂಡಿದೆ, ಆದರೆ "ಕಾವ್ರಿ" ಸ್ಪಷ್ಟವಾಗಿ ಸೂಕ್ತವಲ್ಲ.

ಹೆಚ್ಚುವರಿ ಷರತ್ತು: ಈ ಎಲ್ಲಾ ಆಯ್ಕೆಗಳನ್ನು (ಸರಿಯಾದ ಮತ್ತು ಅಲ್ಲ) ಸಂಖ್ಯೆ ಮಾಡಬೇಕು ಆದ್ದರಿಂದ ನೀವು "ಬಹುಮಾನ" ಕಾರ್ಡ್ ಅನ್ನು ಸ್ವೀಕರಿಸಿದಾಗ ನೀವು ಸಂಖ್ಯೆಯನ್ನು ಪರಿಶೀಲಿಸಬಹುದು (ಒಂದು ಇದೆಯೇ).

1C ಗೂ ಇದಕ್ಕೂ ಏನು ಸಂಬಂಧವಿದೆ ಎಂದು ತೋರುತ್ತದೆ? ಆದ್ದರಿಂದ ಅವರು ಲೆಕ್ಕಪರಿಶೋಧಕ ಪ್ರೋಗ್ರಾಂಗೆ ಈ ಕಾರ್ಡ್‌ಗಳು ಮತ್ತು ಬಹುಮಾನಗಳಿಗೆ ಲೆಕ್ಕಪತ್ರವನ್ನು ಸೇರಿಸಲು ಬಯಸುತ್ತಾರೆ ಮತ್ತು ಅದೇ ಸಮಯದಲ್ಲಿ ಅವರು ಯಾದೃಚ್ಛಿಕ ಸಂಯೋಜನೆಗಳನ್ನು ರಚಿಸಲು ಕೇಳಿದರು (ಅಲ್ಲದೆ, ಅವುಗಳನ್ನು ಕೈಯಾರೆ ಸಂಯೋಜಿಸಬಾರದು).
ಪ್ರತಿ ಪ್ರಚಾರಕ್ಕಾಗಿ, ಸಂಯೋಜನೆಗಳನ್ನು ಒಮ್ಮೆ ರಚಿಸಲಾಗುತ್ತದೆ, ನಂತರ ಕಾರ್ಡ್ಗಳನ್ನು ಅವುಗಳ ಆಧಾರದ ಮೇಲೆ ತಯಾರಿಸಲಾಗುತ್ತದೆ, ಅಂದರೆ. ಮುಂದಿನ ಬಾರಿ ಪದವು ವಿಭಿನ್ನವಾಗಿರುತ್ತದೆ, ಇತ್ಯಾದಿ.

ಸಾಮಾನ್ಯವಾಗಿ, ಕಾರ್ಯವು ಈ ಕೆಳಗಿನವುಗಳಿಗೆ ಕುದಿಯುತ್ತದೆ:
1. ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳನ್ನು ರಚಿಸಿ, ಮೇಲಾಗಿ ದೊಡ್ಡ ಹರಡುವಿಕೆಯೊಂದಿಗೆ.
2. ಸಂಖ್ಯೆಯನ್ನು ಬಳಸಿ, ಅಕ್ಷರಗಳ ಸಂಯೋಜನೆಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಿ (ಅಂದರೆ, ಸಂಭವನೀಯ ಸಂಯೋಜನೆಗಳು ಮತ್ತು ಅವುಗಳ ಸಂಖ್ಯೆಗಳ ನಡುವೆ ಕೆಲವು ಪತ್ರವ್ಯವಹಾರಗಳನ್ನು ಕಂಡುಹಿಡಿಯಿರಿ).
3. ಹಿಂದಿನದಕ್ಕೆ ವಿರುದ್ಧವಾದ ಬಿಂದು - ಪದದ ಮೂಲಕ ಸಂಯೋಜನೆಯ ಸಂಖ್ಯೆಯನ್ನು ಪರಿಶೀಲಿಸಿ.

ಪರಿಹಾರ:
1. ಏಕೆಂದರೆ avb ಮತ್ತು NS ನಿಂದ ಜನರೇಟರ್ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳ ಸಣ್ಣ ಹರಡುವಿಕೆಯನ್ನು ನೀಡಿತು, ನಾನು ಸ್ವಲ್ಪ ವಿಭಿನ್ನ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಬಳಸಬೇಕಾಗಿತ್ತು:

ಫಂಕ್ಷನ್ ರಾಂಡಮ್()
ಖಾಲಿ ಮೌಲ್ಯ (randSeed) = 1 ಆಗಿದ್ದರೆ
randSeed = _getperformancecounter();
endif;

RandSeed=(a*randSeed+c)%m;
ರಾಂಡ್ ಸೀಡ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ;
ಅಂತ್ಯಕ್ರಿಯೆ

ಇಲ್ಲಿ:
a=1664525; c=1013904223; ಮೀ=4294967296;
ಕೊನೆಯ ವೇರಿಯಬಲ್ 2 ರಿಂದ 32 ನೇ ಶಕ್ತಿ, ಇತರ ಎರಡು ಅಂತಹ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಶಿಫಾರಸು ಮಾಡಲಾದ ಗುಣಾಂಕಗಳಾಗಿವೆ

ಗರಿಷ್ಟ ಸಂಖ್ಯೆಯ ಸಂಯೋಜನೆಗಳ ಆಧಾರದ ಮೇಲೆ 2^32 ರ ಗರಿಷ್ಠ ಮೌಲ್ಯದ ಮಿತಿಯನ್ನು ಆಯ್ಕೆ ಮಾಡಲಾಗಿದೆ (28 ಅಕ್ಷರಗಳು ಮತ್ತು ಪ್ರತಿ 7 ಪದಗಳ ಟ್ರಿಮ್ ಮಾಡಿದ ವರ್ಣಮಾಲೆಗೆ, ನೈಜ ಸಮಸ್ಯೆಯಲ್ಲಿ ನಿಖರವಾಗಿ 7 ಇರುವುದರಿಂದ, ಒಟ್ಟು ಸಂಯೋಜನೆಗಳ ಸಂಖ್ಯೆ 28 ಆಗಿರುತ್ತದೆ. ^7, ಹೀಗೆ ಆಯ್ದ ಮಿತಿಯು ಮಧ್ಯಂತರದ ಮಧ್ಯದಲ್ಲಿ ಸರಿಸುಮಾರು ಇರುತ್ತದೆ, ಇದು 20-30 ಸಾವಿರ ಆಯ್ಕೆಗಳ ಮಾದರಿಗೆ ಸಾಕಷ್ಟು ಸಾಕು)

ನಮಗೆ ಇನ್ನೂ ಒಂದು ಸಹಾಯಕ ಕಾರ್ಯದ ಅಗತ್ಯವಿದೆ - ಧನಾತ್ಮಕ ಪೂರ್ಣಾಂಕ ಶಕ್ತಿಗೆ ಏರಿಸುವುದು:

ಫಂಕ್ಷನ್ ಪದವಿ(ಮೌಲ್ಯ a,ಮೌಲ್ಯ b, Res=1)
b>0 ಆಗಿದ್ದರೆ
Res=Res*a;
b=b-1;
ಪದವಿ(a,b,Res);
ರಿಟರ್ನ್ ರೆಸ್;
ಇಲ್ಲದಿದ್ದರೆ
ರಿಟರ್ನ್ ರೆಸ್;
ಕೊನೆಯಲ್ಲಿ ವೇಳೆ;
ಅಂತ್ಯಕ್ರಿಯೆ

ಇಲ್ಲಿ: a - ಪದವಿಯ ಆಧಾರ, b - ಘಾತ, Res - ಫಲಿತಾಂಶ

2. ಅನುಕ್ರಮ ಸಂಯೋಜನೆಗಳ ನಡುವಿನ ಸಂಬಂಧವನ್ನು ಗುರುತಿಸುವುದು ಆಶ್ಚರ್ಯಕರವಾಗಿ ಸರಳವಾಗಿದೆ:

ಹಲವಾರು ಅಂಶಗಳನ್ನು ಕ್ರಮವಾಗಿ ಜೋಡಿಸಿದ ನಂತರ, ಸಂಖ್ಯಾ ವ್ಯವಸ್ಥೆಯೊಂದಿಗೆ ಚಿಹ್ನೆಗಳ ಜೋಡಣೆಯ ಹೋಲಿಕೆಯನ್ನು ನಾನು ಬಹಿರಂಗಪಡಿಸಿದೆ, ದಶಮಾಂಶವಲ್ಲ, ಆದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ “ಹೆಕ್ಸಾಡೆಸಿಮಲ್” (ಪರಿಣಾಮವಾಗಿ “ಪದ” ದಲ್ಲಿನ ಅಕ್ಷರಗಳ ಸಂಖ್ಯೆಯಿಂದ).
ಹೀಗಾಗಿ, ಅದರ ಸಂಖ್ಯೆಯಿಂದ ಸಂಯೋಜನೆಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು, ಅದರ ಸಂಖ್ಯೆಯನ್ನು ಈ ಸಂಖ್ಯೆಯ ವ್ಯವಸ್ಥೆಗೆ ಪರಿವರ್ತಿಸುವುದು ಅಗತ್ಯವಾಗಿತ್ತು.

ನಮ್ಮ ಸಂಖ್ಯಾ ವ್ಯವಸ್ಥೆಗೆ, ಆಧಾರವು ಆರು ಶಕ್ತಿಗಳಾಗಿರುತ್ತದೆ, ಅಂದರೆ. ಎಡಭಾಗದಲ್ಲಿರುವ ಮೊದಲ ಅಂಕಿಯನ್ನು ಪಡೆಯಲು, ನೀವು ನಮ್ಮ ಸಂಯೋಜನೆಯ ಸಂಖ್ಯೆಯನ್ನು 6 ರಿಂದ 5 ನೇ ಶಕ್ತಿಗೆ ಭಾಗಿಸಬೇಕು, ನಂತರ ವಿಭಜನೆಯ ಉಳಿದ ಭಾಗವನ್ನು 6 ರಿಂದ 4 ನೇ ಶಕ್ತಿ, ಇತ್ಯಾದಿ.

ಹೀಗಾಗಿ, ನಾವು ಆರು ಸಂಖ್ಯೆಗಳ ಗುಂಪನ್ನು ಪಡೆಯುತ್ತೇವೆ, ಅವುಗಳು ಮೂಲಭೂತವಾಗಿ ನಮ್ಮ ವರ್ಣಮಾಲೆಯಲ್ಲಿ ಅಕ್ಷರಗಳ ಸರಣಿ ಸಂಖ್ಯೆಗಳಾಗಿವೆ.

ಪರಿಣಾಮವಾಗಿ ಕೋಡ್:

ಫಂಕ್ಷನ್ ಗೆಟ್‌ಕ್ಯಾರೆಕ್ಟರ್‌ಗಳು(ಪೋಸ್,ಟೆಕ್ಸ್‌ಕ್ಯಾರೆಕ್ಟರ್=1,ಸಿಮ್‌ಸ್ಟ್ರ ="")
TekSymv Divisor=Degree(StrLength(Letter),k-TekSymv);
TechOst=Pos%Divider;
SimStr=String(SimStr)+Av(ಅಕ್ಷರಗಳು,ಪೂರ್ಣಾಂಕ(Pos/Divisor+?(TekOst>0,1,0)),1);
GetSymbols(TekOst,TekSymv+1,SymStr);
SimStr ಹಿಂತಿರುಗಿ;
ಇಲ್ಲದಿದ್ದರೆ
SimStr=SimStr+Average(ಲೆಟರ್ಸ್,(?(Pos=0,StrLength(Letters),Pos)),1);
SimStr ಹಿಂತಿರುಗಿ;
ಕೊನೆಯಲ್ಲಿ ವೇಳೆ;
ಅಂತ್ಯಕ್ರಿಯೆ

ಇಲ್ಲಿ:
ಪೋಸ್ - ಸಂಯೋಜನೆ ಸಂಖ್ಯೆ (ಸೂಡೋರಾಂಡಮ್ ಸಂಖ್ಯೆ)
TechSym - ಪ್ರಸ್ತುತ ಚಿಹ್ನೆಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತಿದೆ
SimStr - ಅಕ್ಷರಗಳ ಪರಿಣಾಮವಾಗಿ ಸ್ಟ್ರಿಂಗ್
ಅಕ್ಷರಗಳು = ಪ್ರಮಾಣಿತ ಕ್ರಮದಲ್ಲಿ ವರ್ಣಮಾಲೆಯ ಅಕ್ಷರಗಳನ್ನು ಹೊಂದಿರುವ ಸ್ಟ್ರಿಂಗ್ ("abv...yuya")
k - ಹುಡುಕಾಟ ಪದದಲ್ಲಿನ ಅಕ್ಷರಗಳ ಸಂಖ್ಯೆ (ಈ ಸಂದರ್ಭದಲ್ಲಿ = 6)

3. ಹಿಮ್ಮುಖ ರೂಪಾಂತರವು ಸಹ ಕ್ಷುಲ್ಲಕವಾಗಿದೆ:

ಫಂಕ್ಷನ್ ಗೆಟ್ ಕಾಂಬಿನೇಶನ್(ವರ್ಡ್, ಟೆಕ್ಸ್ ಕ್ಯಾರೆಕ್ಟರ್=0,ಪೋಸ್=0)
NomSymv=Find(Letters,Am(Word,k-TekSymv,1));
TechCym>0 ಆಗಿದ್ದರೆ
TechCym Pos=Pos+(NomCym-1)*Degree(Strength(Letters),TechCym);
ಇಲ್ಲದಿದ್ದರೆ
ರಿಟರ್ನ್ ಪೋಸ್;
ಕೊನೆಯಲ್ಲಿ ವೇಳೆ;
ಇಲ್ಲದಿದ್ದರೆ
Pos=?(NomCym=Strength(Letters),0,NomSymv);
ಗೆಟ್‌ಕಾಂಬಿನೇಶನ್ (ವರ್ಡ್, ಟೆಕ್‌ಕ್ಯಾರೆಕ್ಟರ್ +1, ಪೋಸ್);
ರಿಟರ್ನ್ ಪೋಸ್;
ಕೊನೆಯಲ್ಲಿ ವೇಳೆ;
ಅಂತ್ಯಕ್ರಿಯೆ

ಇಲ್ಲಿ:
ಪದವು ನಾವು ಹುಡುಕುತ್ತಿರುವ ಸಂಖ್ಯೆಗಳ ಅಕ್ಷರಗಳ ಸಂಯೋಜನೆಯಾಗಿದೆ
TekSymv - ಪ್ರಸ್ತುತ ಸಂಕೇತವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತಿದೆ (ಮೂಲಭೂತವಾಗಿ ಹೆಕ್ಸಾಡೆಸಿಮಲ್ "ಸಂಖ್ಯೆ" ನ ಅಂಕೆ)
ಪೋಸ್ - ಬಯಸಿದ ಸಂಯೋಜನೆ ಸಂಖ್ಯೆ

************************

N ಸಂಖ್ಯೆಗಳನ್ನು ಮಿಶ್ರಣ ಮಾಡಿ:

a=1 ರಿಂದ N ಚಕ್ರಕ್ಕೆ
ರಚನೆ[a]=a;
ಚಕ್ರದ ಅಂತ್ಯ;
a=1 ರಿಂದ N-1 ಚಕ್ರಕ್ಕೆ
Sl=Case(a,N);// ಮಧ್ಯಂತರದಲ್ಲಿ ಪೂರ್ಣಾಂಕ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆ [a..N]
ಕೆ=ಅರೇ[a];
ಅರೇ[a]=ಅರೇ[Sl];
ರಚನೆ[Sl]=K;
ಎಂಡ್ಸೈಕಲ್;

//********************************************************************************
************************

Sc = CreateObject("MSScriptControl.ScriptControl");
Sc.language = "VBscript";
sc.executeStatement("ಯಾದೃಚ್ಛಿಕಗೊಳಿಸು");
ಅದು ಇಲ್ಲಿ ಇರುತ್ತದೆ = Sc.eval("rnd");

1 ರಿಂದ 100 ರವರೆಗೆ ಯಾದೃಚ್ಛಿಕವಾಗಿ ಆಯ್ಕೆ ಮಾಡಲಾದ ಸಂಖ್ಯೆಗಳನ್ನು ನಾನು ಹೇಗೆ ಮಾಡಬಹುದು?

Rand=_GetPerformanceCounter()%(100+1);

ಇದು ಅತ್ಯುತ್ತಮವಾಗಿದೆ ಎಂದು ತೋರುತ್ತಿದೆ

//********************************************************************************
************************

8.0 ರಲ್ಲಿ, ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳನ್ನು ರಚಿಸಲು ನೀವು ಅಂತರ್ನಿರ್ಮಿತ GUID ಜನರೇಟರ್ ಅನ್ನು ಬಳಸಬಹುದು.
ಸರಳ ಕಾರ್ಯದ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

//ಪೂರ್ಣಾಂಕಗಳಿಗೆ ಮಾತ್ರ
ಫಂಕ್ಷನ್ GetRandomNumber(ಕನಿಷ್ಟ, ಗರಿಷ್ಠ)

//Randomize ಬದಲಿಗೆ
n = 1 ವರೆಗೆ 100 ಸೈಕಲ್
ವಿಶಿಷ್ಟ = ಹೊಸ ವಿಶಿಷ್ಟ ಗುರುತಿಸುವಿಕೆ;
ಎಂಡ್ಸೈಕಲ್;

//GUID ರಚಿಸಿ
ವಿಶಿಷ್ಟ = AbbrLP(ಹೊಸ ವಿಶಿಷ್ಟ ಗುರುತಿಸುವಿಕೆ);

//ಸಂಖ್ಯೆಗಳನ್ನು ಮಾತ್ರ ಇರಿಸಿ
ವಿಶಿಷ್ಟ = StrReplace(ಅನನ್ಯ,"-","");
ವಿಶಿಷ್ಟ = StrReplace(ಅನನ್ಯ,"a","");
ವಿಶಿಷ್ಟ = StrReplace(ಅನನ್ಯ,"b","");
ವಿಶಿಷ್ಟ = StrReplace(ಅನನ್ಯ,"c","");
ವಿಶಿಷ್ಟ = StrReplace(ಅನನ್ಯ,"d","");
ವಿಶಿಷ್ಟ = StrReplace(ಅನನ್ಯ,"e","");
ವಿಶಿಷ್ಟ = StrReplace(ಅನನ್ಯ,"f","");

//ಛೇದವು ಒಂದೇ ಸಂಖ್ಯೆಯ ಸೊನ್ನೆಗಳು + 1 ಅನ್ನು ಹೊಂದಿರಬೇಕು
ಛೇದ = 10;
n = 2 ರಿಂದ (StrLength(StrReplace(Unique,Characters.NPP,""))) ಲೂಪ್
ಛೇದ = ಛೇದ * 10;
ಎಂಡ್ಸೈಕಲ್;

ಕೇಸ್ = ಸಂಖ್ಯೆ(ಅನನ್ಯ) / ಛೇದ; //ಇಲ್ಲಿ ನಾವು 0 ರಿಂದ 1 ರವರೆಗಿನ ಭಾಗಶಃ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಯನ್ನು ಪಡೆಯುತ್ತೇವೆ

//ಕೊಟ್ಟಿರುವ ಮಧ್ಯಂತರದಿಂದ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗೆ ಪರಿವರ್ತಿಸಿ, ಸುತ್ತಿನಲ್ಲಿ ಹತ್ತಿರದ ಪೂರ್ಣಾಂಕಕ್ಕೆ
ಮಧ್ಯಂತರ ಸಂಖ್ಯೆ = ಕನಿಷ್ಠ(ಗರಿಷ್ಠ(Ab(Min + (Max-Min)*Rand),Min),Max);

ಮಧ್ಯಂತರದಿಂದ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸಿ;

ಅಂತ್ಯಕ್ರಿಯೆ

[ಲಿಂಕ್ ವೀಕ್ಷಿಸಲು ನೀವು ನೋಂದಾಯಿಸಿಕೊಳ್ಳಬೇಕು] ನಿಂದ ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ

//********************************************************************************
************************

ಪಿಎಸ್. ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಯ ಜನರೇಟರ್‌ಗಾಗಿ ಹುಡುಕುತ್ತಿರುವಾಗ ನಾನು ಈ ಲೇಖನವನ್ನು ನೋಡಿದೆ. ಹಾಗಾಗಿ ನನಗಾಗಿ ನಾನು ಆಯ್ಕೆಯನ್ನು ಆರಿಸಿದೆ
Rand=_GetPerformanceCounter()%(100+1);