मैं डार्ट में यादृच्छिक संख्या कैसे उत्पन्न करूं?

Question

मैं डार्ट का उपयोग करके यादृच्छिक संख्या कैसे उत्पन्न करूं?

Comments

आप कैसे जानते हैं कि वे खराब नंबर हैं? यादृच्छिक के बारे में बात यह है कि आप वास्तव में कभी नहीं बता सकते ... i46.tinypic.com/2vw7237.gif

— corsiKa

मेरा विश्वास करो, आपको पता होगा कि यदि आप डार्ट: कोर मैथ का उपयोग करते हैं तो वे खराब हैं। :) यहां बग है: code.google.com/p/dart/issues/detail?id=499

— सेठ लड्ड

यदि आप यह जानना चाहते हैं कि क्या आपके रैंडम नंबर खराब हैं, तो पता लगाने के लिए मेरी चेसक्वेयर लाइब्रेरी का उपयोग करें: github.com/kaisellgren/ChiSquare

— Kai Sellgren

Answer 1

Randomकक्षा का उपयोग करें dart:math:

import 'dart:math';

main() {
  var rng = new Random();
  for (var i = 0; i < 10; i++) {
    print(rng.nextInt(100));
  }
}

इस कोड को डार्ट वीएम और dart2js के साथ परीक्षण किया गया था, इस लेखन के समय के रूप में।

Comments

यदि आप क्रिप्टोग्राफिक रूप से मजबूत यादृच्छिक संख्या चाहते हैं तो आप कक्षा के /dev/urandomसाथ पढ़ना बेहतर Fileसमझते हैं।

— टॉवर

नकारात्मक यादृच्छिक संख्या (युगल) के बारे में कैसे? मैं एक randomRange पद्धति को लागू करने की कोशिश कर रहा हूं, जो उदाहरण के लिए -0.8 से 0.9 तक उत्पन्न होगी ... परिणाम उदाहरण के लिए होगा -0.32

— just_a_dude

@just_a_dude जो स्टैकओवरफ़्लो के लिए एक आदर्श प्रश्न की तरह लगता है। एक नया प्रश्न बनाने पर विचार करें :)

— सेठ लड्ड

विधि जो उदाहरण के लिए -0.8 से 0.9 तक उत्पन्न होगी सरल है। आपको बस मूल्यों को मैप करने की आवश्यकता है। आपकी सीमा 0.8 + 0.9 = 1,7 है। इसलिए अगर आप rng.nextInt (1700) डालते हैं तो आपको 0 से 1700 के बीच नंबर मिलेंगे। 100 से भाग दें और -0,8 घटा दें। मतलब आपका आरएंड = rng.nextInt (1700) / 100.0-0.8। ऐसे और भी विकल्प हैं जिनका आप उपयोग नहीं कर सकते हैं जैसे कि अगली आय का उपयोग न करते हुए बल्कि 0-1 से दोगुना, 1,7 से दुगुना और -0.8 स्थानांतरित

— 17

Answer 2

आप इसे Randomक्लास ऑब्जेक्ट के माध्यम से प्राप्त कर सकते हैं random.nextInt(max), जो dart:mathलाइब्रेरी में है। nextInt()विधि एक अधिकतम सीमा की आवश्यकता है। यादृच्छिक संख्या से शुरू होता है 0और अधिकतम सीमा स्वयं अनन्य है।

import 'dart:math';
Random random = new Random();
int randomNumber = random.nextInt(100); // from 0 upto 99 included

यदि आप न्यूनतम सीमा जोड़ना चाहते हैं, तो परिणाम में न्यूनतम सीमा जोड़ें

int randomNumber = random.nextInt(90) + 10; // from 10 upto 99 included

Comments

क्या आपके उत्तर में 10 से 109 तक की संख्या शामिल नहीं है?

— टिम

@ ध्यान देने के लिए धन्यवाद, मैंने पिछली पंक्ति के कोड की प्रतिलिपि बनाई थी। इसे हल किया।

— समीर रहीमी

Answer 3

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

int random() {
  final ary = new Int32Array(1);
  window.crypto.getRandomValues(ary);
  return ary[0];
}

यह डार्टियम, क्रोम और फ़ायरफ़ॉक्स में काम करता है, लेकिन संभवतः अन्य ब्राउज़रों में नहीं है क्योंकि यह एक प्रयोगात्मक एपीआई है।

Answer 4

यहां यादृच्छिक संख्याओं की सूची बनाने के लिए एक स्निपेट दिया गया है

import 'dart:math';

main() {
  var rng = new Random();
  var l = new List.generate(12, (_) => rng.nextInt(100));
}

यह 0 से 99 (समावेशी) से 12 पूर्णांकों की सूची तैयार करेगा।

Answer 5

एक सुरक्षित रैंडम एपीआई बस में जोड़ा गया था dart:math

new Random.secure()

dart:math Randomएक secureनिर्माता ने एक क्रिप्टोग्राफिक रूप से सुरक्षित यादृच्छिक जनरेटर लौटाया जो कि प्रत्येक उत्पन्न यादृच्छिक मूल्य के लिए एंब्रॉडर द्वारा प्रदान किए गए एन्ट्रापी स्रोत से पढ़ता है।

जो window.crypto.getRandomValues()ब्राउज़र में और ओएस पर (जैसे urandomसर्वर पर) प्रतिनिधि करता है

Comments

यह नया API 1.14-dev या उससे अधिक में उपलब्ध है।

— सेठ लड्ड

Answer 6

टिप्पणी करने में सक्षम नहीं है क्योंकि मैंने अभी यह खाता बनाया है, लेकिन मैं यह बताना चाहता हूं कि @ eggrobot78 का समाधान काम करता है, लेकिन यह डार्ट में अनन्य है, इसलिए इसमें अंतिम संख्या शामिल नहीं है। यदि आप अंतिम पंक्ति को "r = min + rnd.nextInt (अधिकतम - न्यूनतम + 1)" में बदलते हैं, तो इसमें अंतिम संख्या भी शामिल होनी चाहिए।

स्पष्टीकरण:

max = 5;
min = 3;
Random rnd = new Random();
r = min + rnd.nextInt(max - min);
//max - min is 2
//nextInt is exclusive so nextInt will return 0 through 1
//3 is added so the line will give a number between 3 and 4
//if you add the "+ 1" then it will return a number between 3 and 5

Answer 7

इसे आज़माएं, आप न्यूनतम / अधिकतम मूल्य को नियंत्रित कर सकते हैं:

import 'dart:math';

void main(){
  random(min, max){
    var rn = new Random();
    return min + rn.nextInt(max - min);
  }
  print(random(5,20)); // Output : 19, 6, 15..
}

Answer 8

एक वैकल्पिक समाधान निम्नलिखित कोड DRandom का उपयोग किया जा सकता है । इस वर्ग का उपयोग बीज के साथ किया जाना चाहिए। यह एक परिचित इंटरफ़ेस प्रदान करता है कि आप .NET में क्या उम्मीद करेंगे, इसे मोनो के रैंडम.क्स से पोर्ट किया गया था। यह कोड क्रिप्टोग्राफी सुरक्षित नहीं हो सकता है और सांख्यिकीय रूप से परीक्षण नहीं किया गया है।

Comments

मैंने पहले भी डीआरजीएम का उपयोग किया है। अच्छा काम!

— जॉन इवांस

Answer 9

नॉर्मल रैंडम नंबर्स जेनरेट करने के लिए इस छोटी सी क्लास को लिखा ... यह चेकिंग के लिए एक अच्छी शुरुआत थी जो मुझे करने की जरूरत है। (ये सेट "घंटी" के आकार के वक्र पर वितरित करेंगे। बीज को बेतरतीब ढंग से सेट किया जाएगा, लेकिन अगर आप एक सेट को फिर से तैयार करने में सक्षम होना चाहते हैं तो आप बस कुछ विशिष्ट बीज पास कर सकते हैं और एक ही सेट उत्पन्न करेगा।

मज़े करो...

class RandomNormal {
  num     _min, _max,  _sum;
  int     _nEle, _seed, _hLim;
  Random  _random;
  List    _rNAr;

  //getter
  List get randomNumberAr => _rNAr;

  num _randomN() {
    int r0 = _random.nextInt(_hLim);
    int r1 = _random.nextInt(_hLim);
    int r2 = _random.nextInt(_hLim);
    int r3 = _random.nextInt(_hLim);

    num rslt = _min + (r0 + r1 + r2 + r3) / 4000.0;  //Add the OS back in...
    _sum += rslt; //#DEBUG ONLY
    return( rslt );
  }

  RandomNormal(this._nEle, this._min, this._max, [this._seed = null]) {
    if (_seed == null ) {
      Random r = new Random();
      _seed    = r.nextInt(1000);
    }
    _hLim   = (_max - _min).ceil() * 1000;
    _random = new Random(_seed);
    _rNAr   = [];
    _sum    = 0;//#DEBUG ONLY

    h2("RandomNormal with k: ${_nEle}, Seed: ${_seed}, Min: ${_min}, Max: ${_max}");//#DEBUG ONLY
    for(int n = 0; n < _nEle; n++ ){
      num randomN = _randomN();
      //p("randomN  = ${randomN}");
      LIST_add( _rNAr, randomN );
    }

    h3("Mean = ${_sum/_nEle}");//#DEBUG ONLY
  }
}


new RandomNormal(1000, 80, 120);
new RandomNormal(1000, 80, 120);
new RandomNormal(1000, 80, 120);
new RandomNormal(1000, 80, 120);
new RandomNormal(1000, 80, 120);
new RandomNormal(1000, 80, 120);
new RandomNormal(1000, 80, 120);

फिर आप इसे इस तरह उपयोग कर सकते हैं कि कम और उच्च सीमा के बीच उत्पन्न 1000 अंकों के सेट की जांच करें। मानों को कक्षा में संग्रहीत किया जाता है, ताकि उन्हें तात्कालिकता के बाद एक्सेस किया जा सके।

_swarmii

Answer 10

इस लाइब्रेरी का उपयोग करें http://dart.googlecode.com/svn/branches/bleeding_edge/dart/lib/math/random.dart ने एक अच्छा यादृच्छिक जनरेटर प्रदान किया, जो मुझे लगता है कि sdk में शामिल होगा जल्द ही आशा है कि यह मदद करता है

Comments

यह अब एसडीके में है। इसका उपयोग कैसे करें, इसके लिए ऊपर मेरा उत्तर देखें।

— सेठ लड्ड

Answer 11

मेरे लिए सबसे आसान तरीका है:

import 'dart:math';
Random rnd = new Random();
r = min + rnd.nextInt(max - min);
//where min and max should be specified.

यहाँ @ @ अदम-गायक स्पष्टीकरण के लिए धन्यवाद ।

Answer 12

मेरे लिए यह काम किया new Random().nextInt(100); // MAX = number

यह 0 से 99 रैंडम नंबर देगा

Eample ::

import 'dart:math';
int MAX = 100;
print(new Random().nextInt(MAX));`

Answer 13

मुझे एक सरल डाइस रोलिंग ऐप के रूप में एक व्यावहारिक उदाहरण के साथ इस प्रश्न को हल करने दें जो 6 डाइस चेहरे की छवियों में से 1 को बेतरतीब ढंग से टैप करने पर स्क्रीन पर कॉल करता है।

पहले एक वेरिएबल घोषित करें जो रैंडम नंबर जेनरेट करता है (डार्टमैथ आयात करना न भूलें)। फिर एक वैरिएबल घोषित करें जो 1 और 6 के बीच बाधाओं के भीतर प्रारंभिक यादृच्छिक संख्या को पूर्णांक के रूप में बताता है।

दोनों वैरिएबल एक बार आरंभिक होने के लिए स्थिर निजी होते हैं। यह बहुत बड़ी बात नहीं है, लेकिन अच्छा होगा यदि आपको रैंडम नंबरों के पूरे समूह को इनिशियलाइज़ करना है।

static var _random = new Random();
static var _diceface = _rnd.nextInt(6) +1 ;

अब टेप के साथ क्लिपरेक्ट के साथ एक जेस्चर डिटेक्शन विजेट बनाएं जब टैप किए जाने पर छह पासा फेस इमेज में से एक को वापस करने के लिए।

GestureDetector(
          onTap: () {
            setState(() {
              _diceface = _rnd.nextInt(6) +1 ;
            });
          },
          child: ClipRRect(
            clipBehavior: Clip.hardEdge,
            borderRadius: BorderRadius.circular(100.8),
              child: Image(
                image: AssetImage('images/diceface$_diceface.png'),
                fit: BoxFit.cover,
              ),
          )
        ),

हर बार जब आप स्क्रीन पर टैप करते हैं तो एक नया रैंडम नंबर जेनरेट होता है और उस नंबर का चयन करने के लिए संदर्भित किया जाता है कि कौन सा डाइस फेस इमेज चुना गया है।

मुझे आशा है कि इस उदाहरण से मदद मिली :)

डार्ट में डाइस रॉलिंग ऐप रैंडम नंबरों का उपयोग कर