Let's use the random class to write a program that uses a loop to simulate
tossing a 6 sided die 100 times. The die can come up 1, 2, 3, 4, 5, or 6. Write
your program so that it prints the number of sixes that come up. You'll need to
import java.util.Random to use a random generator. So then I can help you check
your work. We're going to do a bit of a magic trick. Random generators can be
seeded. What that means is you give them a number to start rolling from, and
then they grow a pattern based on that seed. So the sequence they generate will
look random, but if you create another random generator like this, they'll both
generate the exact same sequence. So all you need to know about that for now,
is to declare your random generator this way. Because the grading code will be
expecting a sequence of numbers generated with this seed. If you're not sure
what I'm talking about, and you're curious, stick around for a moment and I'll
demo what this does. But feel free to skip to the quiz. My trusty code pad.
I'll create and seed a random generator, and now I'll do the exact same thing,
and make another one. Now if I ask the first generator for an int, I'll get 2.
And if I ask the other generator for exactly the same thing, I will also get 2.
I can do this again, and they still both agree. So while I'm getting random
numbers out of this, The numbers are predictable, so we know what to expect and
can help you debug your code.
Vamos a utilizar la clase «Random» para escribir un programa que utilice un bucle para simular
que se lanza un dado de 6 lados, cien veces. El dado puede caer en 1, 2, 3, 4, 5 o 6. Escriban
su programa de tal manera que imprima el número de veces que cae en 6. Necesitarán
importar «java.util.Random» para utilizar un generador aleatorio. Para que les pueda ayudar a revisar
su trabajo, vamos a hacer una especie de truco de magia. Los generadores aleatorios se pueden
sembrar. Lo que esto significa es que ustedes les dan un número en el cual empiezan a rodar, y
luego, desarrollan un patrón que se basa en lo que se sembró. Así que la secuencia que generan parecerá
aleatoria, pero si crean otro generador aleatorio de este tipo, ambos
generarán la misma secuencia exacta. Así que todo lo que necesitan saber acerca de eso por ahora,
es declarar su generador aleatorio de esta manera, porque el código de calificación estará
esperando una secuencia de números generados con esta semilla. Si no están seguros
de lo que estoy hablando y tienen curiosidad, quédense un momento
y haré un demo de lo que esto hace. Pero no duden en pasar a la prueba. En mi libreta de código de confianza
Voy a crear y sembrar un generador aleatorio, y ahora voy a hacer exactamente lo mismo
y voy a hacer otro. Bien, si le pido al primer generador un «int», voy a obtener 2.
Y si le pido al otro generador exactamente lo mismo, también obtendré 2.
Puedo hacer esto de nuevo, y ambos aún concuerdan. Así que mientras obtengo
números aleatorios de esto, los números son predecibles, por lo que sabemos qué esperar y
les puede ayudar a depurar el código.
Utilisons la classe random pour écrire un programme
qui utilise une boucle pour simuler le lancé un dé à 6 faces 100 fois.
Le dé peut produire 1, 2, 3, 4, 5 ou 6.
Écrivez votre programme afin qu'il imprime le nombre de 6 qui viennent.
Vous devrez importer java.util.Random pour utiliser un générateur aléatoire.
Pour que je puisse vérifier votre travail,
nous allons faire un peu de magie.
Les générateurs aléatoires peuvent être ensemencés.
Ça signifie que vous donnez un nombre à partir duquel ils grandissent
et ils développent un modèle basé sur cette graine.
Ainsi, la séquence qu'ils génèrent semblera aléatoire,
mais si vous créez un autre générateur aléatoire comme celui-ci,
ils généreront tous les deux exactement la même séquence.
Tout ce qu'il faut savoir à ce sujet pour l'instant
c'est de déclarer le générateur aléatoire ainsi
car le code de notation s'attend
à une séquence de nombres générés avec cette graine.
Si vous ne voyez pas de quoi je parle et vous êtes curieux,
restez encore et je ferai une démo ce que cela fait.
Mais n'hésitez pas à passer au quiz.
Mon bloc de code fidèle.
Je vais créer et semer un générateur aléatoire,
et je vais faire exactement la même chose et en faire un autre.
Maintenant, si je demande un int au premier générateur, j'en aurai 2.
Et si je demande exactement la même chose à l'autre générateur,
j'obtiendrai aussi 2.
Je peux le faire encore et ils sont toujours d'accord.
Donc, bien que je reçoive des nombres aléatoires,
ils sont prévisibles, nous savons à quoi nous attendre
et pouvons vous aider à déboguer votre code.
Randomクラスを使い ループを用いたプログラムを書きましょう
それを使って6面のサイコロを 100回投げる実験をします
サイコロの目は1～6のいずれかです
現れる6つの数字を出力できるよう プログラムを書きます
乱数ジェネレータを使うため java．util．Randomをインポートすれば
皆さんのプログラムを確認できます 次は手品みたいですよ
乱数ジェネレータに初期値 つまり最初の乱数種を与えれば
種を基にパターンが増え その結果作られた数列は乱数に見えます
しかし別の乱数ジェネレータを作るとしたら
まったく同じ数列が得られます ここで大事なことは
乱数ジェネレータをこのように宣言することです
コードはこの種から作られる数列と 想定されるからです
ここまで理解できなくても興味があれば 一緒に見ていきましょう
実際にやってみますが この問題を飛ばしても結構です
コードパッドに乱数ジェネレータを作成して 乱数の初期値を設定します
同様にジェネレータをもう1つ作成します
最初のジェネレータをint型とすれば 2が得られます
もう1つのジェネレータに同じことをすれば やはり2が得られます
もう一度やってみても結果は同じです
ここから乱数を得る場合その数は予測可能なので
コードのデバックにも役立ちます
Random 클래스를 이용해서 6면을 가진 주사위를 100번 던지는 시뮬레이션을 하는
프로그램을 작성해 봅시다. 주사위는 1, 2, 3, 4, 5, 6이 나타납니다.
저 여섯 개의 숫자를 출력할 수 있도록 프로그램을 작성하세요. 여러분은
java.util.Random을 import해야 합니다. 이제
신기한 것을 보여드리겠습니다. 난수 생성기들은 고정될 수 있습니다.
그 뜻은, SEED라는 숫자로 시작해서, SEED에 의해
패턴을 만들게 됩니다. 그래서 난수 생성기는
무작위인 것 처럼 보이지만, 이와 같은 난수 생성기를 생성하면 그 둘은
똑같은 순서로 숫자를 생성합니다. 결론적으로, 여러분은 난수 생성기를
이와 같이 작성하시면 됩니다. 왜냐하면 이 SEED에 의해 생성된
순서의 숫자들이 필요하기 때문입니다. 제가 무슨 말을 하는지 모른다거나
조금 더 알고 싶다면, 무슨 뜻인지 제가 보여드리겠습니다.
하지만 이해를 했다면 퀴즈로 바로 넘어가세요.
여기에 난수 생성기를 SEED와 함께 생성하겠습니다. 이제
이와 똑같이 생성하겠습니다. 이제 첫 번째 생성기에 int를 생성하면 2를 받습니다.
두 번째 생성기한테 int를 생성하라고 했는데도 불구하고 2를 받습니다.
이를 똑같이 하면 두 난수 생성기 모두 같은 값을 출력합니다. 이렇게
한다면 무작위의 숫자를 예상할 수 있게 되어서 코드를 디버깅하는데
많은 도움이 됩니다.