मुझे कोटलिन में एक यादृच्छिक संख्या कैसे मिल सकती है?

Question

एक सामान्य विधि जो रूबी की तरह 2 मापदंडों के बीच एक यादृच्छिक पूर्णांक लौटा सकती है rand(0..n)।

कोई उपाय?

Answer 1

मेरा सुझाव Intandange पर एक विस्तार समारोह इस तरह से रैंडम बनाने के लिए होगा:(0..10).random()

टीएल; डीआर कोटलिन> = 1.3, सभी प्लेटफार्मों के लिए एक यादृच्छिक

1.3 के रूप में, कोटलिन अपने स्वयं के मल्टी-प्लेटफॉर्म रैंडम जनरेटर के साथ आता है। यह इस KEEP में वर्णित है । नीचे वर्णित विस्तार अब कोटलिन मानक पुस्तकालय का हिस्सा है , बस इसे इस तरह उपयोग करें:

val rnds = (0..10).random()

---

कोटलिन <1.3

1.3 से पहले, जेवीएम पर हम उपयोग करते हैं Randomया भले ThreadLocalRandomही हम जेडडीके> 1.6 पर हों।

fun IntRange.random() = 
       Random().nextInt((endInclusive + 1) - start) + start

इस तरह इस्तेमाल किया:

// will return an `Int` between 0 and 10 (incl.)
(0..10).random()

यदि आप चाहते थे कि फ़ंक्शन केवल वापस लौटे 1, 2, ..., 9( 10शामिल नहीं), तो इसके साथ निर्मित रेंज का उपयोग करें until:

(0 until 10).random()

यदि आप JDK> 1.6 के साथ काम कर रहे हैं, तो ThreadLocalRandom.current()इसके बजाय का उपयोग करें Random()।

KotlinJs और अन्य बदलाव

Kotlinjs और अन्य उपयोग के मामलों के लिए जो इसके उपयोग की अनुमति नहीं देते हैं java.util.Random, इस विकल्प को देखें ।

इसके अलावा, मेरे सुझाव की विविधताओं के लिए इस उत्तर को देखें । इसमें यादृच्छिक Chars के लिए एक एक्सटेंशन फ़ंक्शन भी शामिल है ।

Comments

मुझे लगता है यह भी जावा का उपयोग करता है java.util.Random?

— साइमन फोर्सबर्ग

@SimonForsberg वास्तव में। मैंने एक और उत्तर जोड़ा जो इसका उपयोग नहीं करता है: stackoverflow.com/a/49507413/8073652

— s1m0nw1

क्रिप्टोग्राफिक रूप से सुरक्षित छद्म-रैंडम नंबर जेनरेटर (CSPRNG) को यहाँ जोड़ने का एक प्रस्ताव यहाँ भी है: github.com/Kotlin/KEEP/issues/184

— जोनाथन लीत्सुच

Answer 2

from(समावेशी) और to(अनन्य) के बीच एक यादृच्छिक पूर्णांक बनाएं

import java.util.Random

val random = Random()

fun rand(from: Int, to: Int) : Int {
    return random.nextInt(to - from) + from
}

Comments

यदि आप रैंडम रैंडम Intएस की एक जोड़ी प्राप्त करना चाहते हैं , तो आप जावा -8 के बजाय रैंडम # इंट (आकार, से,) का उपयोग कर सकते हैं ।

— होली-जावा

यह समाधान जावास्क्रिप्ट / नेटिव कोटलिन पर काम नहीं करता है। शायद ऐसा करने के लिए अधिक सामान्य विधि बनाने के लिए यह शांत हो सकता है। :)

— वैलेंटाइन मिशालक

@ValentinMichalak आप इसे आज़मा सकते हैं: stackoverflow.com/a/49507413/8073652

— s1m0nw1

Answer 3

कोटलिन 1.2 के रूप में, आप लिख सकते हैं:

(1..3).shuffled().last()

बस जागरूक रहें यह बड़ा ओ (एन) है, लेकिन एक छोटी सूची (विशेष रूप से अद्वितीय मूल्यों) के लिए यह ठीक है: डी

Comments

यह एक kotlin- देशी के लिए उपयोगी है

— user3471194

Answer 4

आप इसके समान एक एक्सटेंशन फ़ंक्शन बना सकते हैं, java.util.Random.nextInt(int)लेकिन IntRangeइसके बजाए इसके बजाय एक Int:

fun Random.nextInt(range: IntRange): Int {
    return range.start + nextInt(range.last - range.start)
}

अब आप इसे किसी भी Randomउदाहरण के साथ उपयोग कर सकते हैं :

val random = Random()
println(random.nextInt(5..9)) // prints 5, 6, 7, or 8

यदि आप अपने स्वयं के Randomउदाहरण का प्रबंधन नहीं करना चाहते हैं तो आप उदाहरण के लिए, एक सुविधा विधि को परिभाषित कर सकते हैं ThreadLocalRandom.current():

fun rand(range: IntRange): Int {
    return ThreadLocalRandom.current().nextInt(range)
}

अब आप एक यादृच्छिक पूर्णांक प्राप्त कर सकते हैं जैसा कि आप रूबी में पहले Randomउदाहरण के लिए खुद को घोषित किए बिना कर सकते हैं:

rand(5..9) // returns 5, 6, 7, or 8

Answer 5

यादृच्छिक वर्णों के लिए मेरे अन्य उत्तर के लिए संभावित विविधता

यादृच्छिक Chars प्राप्त करने के लिए , आप इस तरह से एक एक्सटेंशन फ़ंक्शन को परिभाषित कर सकते हैं

fun ClosedRange<Char>.random(): Char = 
       (Random().nextInt(endInclusive.toInt() + 1 - start.toInt()) + start.toInt()).toChar()

// will return a `Char` between A and Z (incl.)
('A'..'Z').random()

यदि आप JDK> 1.6 के साथ काम कर रहे हैं, तो ThreadLocalRandom.current() इसके बजाय का उपयोग करेंRandom() ।

Kotlinjs और अन्य उपयोग के मामलों के लिए जो इसके उपयोग की अनुमति नहीं देते हैं java.util.Random, यह उत्तर मदद करेगा।

रैंडल के लिए कोटलिन> = 1.3 मल्टीप्लायर का समर्थन करता है

1.3 के रूप में, कोटलिन अपने स्वयं के मल्टीप्लायर रैंडम जनरेटर के साथ आता है। यह इस KEEP में वर्णित है । अब आप सीधे इसे परिभाषित किए बिना कोटलिन मानक पुस्तकालय के हिस्से के रूप में विस्तार का उपयोग कर सकते हैं:

('a'..'b').random()

Answer 6

@ S1m0nw1 उत्कृष्ट उत्तर के निर्माण से मैंने निम्नलिखित बदलाव किए।

1. (0..n) का तात्पर्य कोटलिन में सम्मिलित है
2. (0 तक n) कोटलिन में अनन्य का अर्थ है
3. रैंडम उदाहरण (वैकल्पिक) के लिए एक सिंगलटन ऑब्जेक्ट का उपयोग करें

कोड:

private object RandomRangeSingleton : Random()

fun ClosedRange<Int>.random() = RandomRangeSingleton.nextInt((endInclusive + 1) - start) + start

परीक्षण का मामला:

fun testRandom() {
        Assert.assertTrue(
                (0..1000).all {
                    (0..5).contains((0..5).random())
                }
        )
        Assert.assertTrue(
                (0..1000).all {
                    (0..4).contains((0 until 5).random())
                }
        )
        Assert.assertFalse(
                (0..1000).all {
                    (0..4).contains((0..5).random())
                }
        )
    }

Answer 7

सीमा में यादृच्छिक उदाहरण [1, 10]

val random1 = (0..10).shuffled().last()

या जावा रैंडम का उपयोग

val random2 = Random().nextInt(10) + 1

Comments

आपका पहला जवाब मुझे सबसे ज्यादा पसंद है। यह एक आदर्श वन-लाइनर है जिसे किसी भी विस्तार कार्य को लिखने की आवश्यकता नहीं है

— एलेक्स सेमेनीक

Answer 8

कोटलिन = = 1.3, रैंडम के लिए मल्टीप्लेट रिकॉर्डर समर्थन

1.3 के रूप में, मानक पुस्तकालय ने रैंडम के लिए बहु-प्लेटफ़ॉर्म समर्थन प्रदान किया, यह उत्तर देखें ।

कोटलिन <1.3 जावास्क्रिप्ट पर

यदि आप कोटलिन जावास्क्रिप्ट के साथ काम कर रहे हैं और आप तक पहुँच नहीं है java.util.Random, तो निम्नलिखित काम करेंगे:

fun IntRange.random() = (Math.random() * ((endInclusive + 1) - start) + start).toInt()

इस तरह इस्तेमाल किया:

// will return an `Int` between 0 and 10 (incl.)
(0..10).random()

Answer 9

S1m0nw1 के उत्तर को लागू करने का एक अन्य तरीका यह होगा कि इसे एक चर के माध्यम से एक्सेस किया जाए। ऐसा नहीं है कि यह किसी भी अधिक कुशल है, लेकिन यह आपको टाइप करने से बचाता है ()।

val ClosedRange<Int>.random: Int
    get() = Random().nextInt((endInclusive + 1) - start) +  start 

और अब इसे इस तरह एक्सेस किया जा सकता है

(1..10).random

Answer 10

Kotlin 1.3 में आप इसे पसंद कर सकते हैं

val number = Random.nextInt(limit)

Answer 11

कोई मानक विधि नहीं है जो ऐसा करती है लेकिन आप आसानी से Math.random()या तो या कक्षा का उपयोग करके अपना खुद का बना सकते हैं java.util.Random। यहां Math.random()विधि का उपयोग करके एक उदाहरण दिया गया है:

fun random(n: Int) = (Math.random() * n).toInt()
fun random(from: Int, to: Int) = (Math.random() * (to - from) + from).toInt()
fun random(pair: Pair<Int, Int>) = random(pair.first, pair.second)

fun main(args: Array<String>) {
    val n = 10

    val rand1 = random(n)
    val rand2 = random(5, n)
    val rand3 = random(5 to n)

    println(List(10) { random(n) })
    println(List(10) { random(5 to n) })
}

यह एक नमूना आउटपुट है:

[9, 8, 1, 7, 5, 6, 9, 8, 1, 9]
[5, 8, 9, 7, 6, 6, 8, 6, 7, 9]

Answer 12

Kotlin मानक काम यादृच्छिक संख्या जनरेटर एपीआई प्रदान नहीं करता है। यदि आप एक मल्टीप्लायर प्रोजेक्ट में नहीं हैं, तो प्लेटफ़ॉर्म एपी (अन्य सभी सवालों के जवाब इस समाधान के बारे में बात करते हैं) का उपयोग करना बेहतर है ।

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

मेरी व्यक्तिगत परियोजना में इस समस्या का उत्तर देने के लिए, मैं एक शुद्ध कोटलिन रैखिक बधाई जेनरेटर लागू करता हूं । LCG एल्गोरिथ्म द्वारा उपयोग किया जाता है java.util.Random। यदि आप इसका उपयोग करना चाहते हैं तो इस लिंक का अनुसरण करें: https://gist.github.com/11e5ddb567786af0ed1ae4d7f57441d4

आपके लिए मेरा कार्यान्वयन उद्देश्य nextInt(range: IntRange);)

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

Comments

मैं अपने खुद के यादृच्छिक एल्गोरिथ्म बनाने की तुलना में प्लेटफ़ॉर्म विशिष्ट कोड पर भरोसा करता हूं। यह मुझे java.util.Random के कोड के बारे में थोड़ा याद दिलाता है, लेकिन यह पूरी तरह से मेल नहीं खाता है।

— साइमन फोर्सबर्ग

Answer 13

यदि आप जिन नंबरों को चुनना चाहते हैं, वे लगातार नहीं हैं, तो आप उपयोग कर सकते हैं random()।

उपयोग:

val list = listOf(3, 1, 4, 5)
val number = list.random()

सूची में जो संख्याएँ हैं उनमें से एक को लौटाता है।

Answer 14

अब कस्टम एक्सटेंशन फ़ंक्शंस का उपयोग करने की आवश्यकता नहीं है। IntRange में अब एक random()आउट-ऑफ-द-बॉक्स एक्सटेंशन फ़ंक्शन है।

val randomNumber = (0..10).random()

Answer 15

एक शीर्ष-स्तरीय फ़ंक्शन का उपयोग करते हुए, आप रूबी के समान कॉल सिंटैक्स प्राप्त कर सकते हैं (जैसा आप चाहते हैं):

fun rand(s: Int, e: Int) = Random.nextInt(s, e + 1)

उपयोग:

rand(1, 3) // returns either 1, 2 or 3

Answer 16

सबसे पहले, आपको एक आरएनजी चाहिए। कोटलिन में आपको वर्तमान में प्लेटफ़ॉर्म विशिष्ट लोगों का उपयोग करने की आवश्यकता है (एक में निर्मित कोटलिन नहीं है)। जेवीएम के लिए java.util.Random। आपको इसका एक उदाहरण बनाना होगा और फिर कॉल करना होगा random.nextInt(n)।

Answer 17

Kotlin में एक यादृच्छिक Int संख्या प्राप्त करने के लिए निम्नलिखित विधि का उपयोग करें :

import java.util.concurrent.ThreadLocalRandom

fun randomInt(rangeFirstNum:Int, rangeLastNum:Int) {
    val randomInteger = ThreadLocalRandom.current().nextInt(rangeFirstNum,rangeLastNum)
    println(randomInteger)
}
fun main() {    
    randomInt(1,10)
}


// Result – random Int numbers from 1 to 9

उम्मीद है की यह मदद करेगा।

Answer 18

आप एक एक्सटेंशन फ़ंक्शन बना सकते हैं:

infix fun ClosedRange<Float>.step(step: Float): Iterable<Float> {
    require(start.isFinite())
    require(endInclusive.isFinite())
    require(step.round() > 0.0) { "Step must be positive, was: $step." }
    require(start != endInclusive) { "Start and endInclusive must not be the same"}

    if (endInclusive > start) {
        return generateSequence(start) { previous ->
            if (previous == Float.POSITIVE_INFINITY) return@generateSequence null
            val next = previous + step.round()
            if (next > endInclusive) null else next.round()
        }.asIterable()
    }

    return generateSequence(start) { previous ->
        if (previous == Float.NEGATIVE_INFINITY) return@generateSequence null
        val next = previous - step.round()
        if (next < endInclusive) null else next.round()
    }.asIterable()
}

दौर फ्लोट मूल्य:

fun Float.round(decimals: Int = DIGITS): Float {
    var multiplier = 1.0f
    repeat(decimals) { multiplier *= 10 }
    return round(this * multiplier) / multiplier
}

विधि का उपयोग:

(0.0f .. 1.0f).step(.1f).forEach { System.out.println("value: $it") }

आउटपुट:

मूल्य: 0.0 मूल्य: 0.1 मूल्य: 0.2 मूल्य: 0.3 मूल्य: 0.4 मूल्य: 0.5 मूल्य: 0.6 मूल्य: 0.7 मूल्य: 0.8 मूल्य: 0.8 मूल्य: 1.0

Answer 19

पूर्ण स्रोत कोड। नियंत्रित कर सकते हैं कि डुप्लिकेट की अनुमति है या नहीं।

import kotlin.math.min

abstract class Random {

    companion object {
        fun string(length: Int, isUnique: Boolean = false): String {
            if (0 == length) return ""
            val alphabet: List<Char> = ('a'..'z') + ('A'..'Z') + ('0'..'9') // Add your set here.

            if (isUnique) {
                val limit = min(length, alphabet.count())
                val set = mutableSetOf<Char>()
                do { set.add(alphabet.random()) } while (set.count() != limit)
                return set.joinToString("")
            }
            return List(length) { alphabet.random() }.joinToString("")
        }

        fun alphabet(length: Int, isUnique: Boolean = false): String {
            if (0 == length) return ""
            val alphabet = ('A'..'Z')
            if (isUnique) {
                val limit = min(length, alphabet.count())
                val set = mutableSetOf<Char>()
                do { set.add(alphabet.random()) } while (set.count() != limit)
                return set.joinToString("")
            }

            return List(length) { alphabet.random() }.joinToString("")
        }
    }
}

Answer 20

जब भी कोई ऐसी स्थिति होती है, जिसमें आप कुंजी या मैक एड्रेस जेनरेट करना चाहते हैं, जो कि हेक्साडेसिमल नंबर होता है, जिसमें उपयोगकर्ता की मांग के आधार पर अंक होते हैं, और वह भी एंड्रॉइड और कोटलिन का उपयोग करके, तो आप मेरे नीचे दिए गए कोड में आपकी मदद करते हैं:

private fun getRandomHexString(random: SecureRandom, numOfCharsToBePresentInTheHexString: Int): String {
    val sb = StringBuilder()
    while (sb.length < numOfCharsToBePresentInTheHexString) {
        val randomNumber = random.nextInt()
        val number = String.format("%08X", randomNumber)
        sb.append(number)
    }
    return sb.toString()
} 

Answer 21

सुपर डुपर होना)

 fun rnd_int(min: Int, max: Int): Int {
        var max = max
        max -= min
        return (Math.random() * ++max).toInt() + min
    }