Le prix de vente des petits (prix en semaine à Tanuki Shoten) dans "Atsumare Animal Forest" fluctuerait entre 9 et 660 cloches </ b>, en particulier le prix le plus élevé de 660 cloches et le prix le plus bas de 9 cloches. On dit qu'il est très rare de sortir. Par conséquent, calculons la probabilité que les prix les plus élevés et les plus bas apparaissent dans une semaine donnée.
Le modèle de fluctuation du prix du petit peut être grossièrement divisé en quatre types.
Le prix le plus élevé se produit uniquement dans "3. Grand rebond", et le prix le plus bas se produit uniquement dans "4. Petit rebond". Par conséquent, essayez d'abord de trouver la probabilité de chaque type.
La probabilité de devenir chaque type est déterminée uniquement par le type de la semaine précédente (chaîne de Markov), comme indiqué dans le tableau ci-dessous. (Lignes de code de résultat d'analyse 135-209)
| La semaine dernière\cette semaine | Type réduit | Type d'onde | Rebondir grand | Rebondir petit |
|---|---|---|---|---|
| Type réduit | 5% | 25% | 45% | 25% |
| Type d'onde | 15% | 20% | 30% | 35% |
| Rebondir grand | 20% | 50% | 5% | 25% |
| Rebondir petit | 15% | 45% | 25% | 15% |
À partir de ce tableau, essayez de trouver la probabilité (distribution régulière) que chaque type converge lorsque le nombre de semaines de jeu approche de l'infini par la méthode du site suivant. (Il est nécessaire de prouver qu'il converge réellement, mais il est omis ici.) https://withcation.com/2020/01/23/%E3%83%9E%E3%83%AB%E3%82%B3%E3%83%95%E9%80%A3%E9%8E%96%E3%81%AE%E5%AE%9A%E5%B8%B8%E5%88%86%E5%B8%83%E3%82%92%E8%A7%A3%E3%81%8F/
En supposant que les probabilités de type réduit, type ondulé, grand rebond et petit rebond sont respectivement $ a, b, c et d $, l'équation suivante est vraie.
\begin{pmatrix}
a & b & c & d
\end{pmatrix}
\begin{pmatrix}
0.05 & 0.25 & 0.45 & 0.25 \\
0.15 & 0.20 & 0.30 & 0.35 \\
0.20 & 0.50 & 0.05 & 0.25 \\
0.15 & 0.45 & 0.25 & 0.15 \\
\end{pmatrix}
=
\begin{pmatrix}
a & b & c & d
\end{pmatrix}
Transfert
\begin{pmatrix}
a & b & c & d
\end{pmatrix}
\begin{pmatrix}
-0.95 & 0.25 & 0.45 & 0.25 \\
0.15 & -0.80 & 0.30 & 0.35 \\
0.20 & 0.50 & -0.95 & 0.25 \\
0.15 & 0.45 & 0.25 & -0.85 \\
\end{pmatrix}
=
\begin{pmatrix}
0 & 0 & 0 & 0
\end{pmatrix}
À première vue, il semble que les équations simultanées de 4 équations utilisant 4 types de caractères sont exprimées dans une matrice, mais en fait, si 3 équations sont transformées, la 1 équation restante sera laissée, donc une équation est manquante (matrice 4x4). L'expression matricielle de est 0 et la matrice inverse ne peut pas être obtenue). Par conséquent, intégrez $ a + b + c + d = 1 $ dans n'importe quelle colonne (ici, la première colonne).
\begin{pmatrix}
a & b & c & d
\end{pmatrix}
\begin{pmatrix}
1 & 0.25 & 0.45 & 0.25 \\
1 & -0.80 & 0.30 & 0.35 \\
1 & 0.50 & -0.95 & 0.25 \\
1 & 0.45 & 0.25 & -0.85 \\
\end{pmatrix}
=
\begin{pmatrix}
1 & 0 & 0 & 0
\end{pmatrix}
\\
\begin{pmatrix}
a & b & c & d
\end{pmatrix}
=
\begin{pmatrix}
1 & 0 & 0 & 0
\end{pmatrix}
\begin{pmatrix}
1 & 0.25 & 0.45 & 0.25 \\
1 & -0.80 & 0.30 & 0.35 \\
1 & 0.50 & -0.95 & 0.25 \\
1 & 0.45 & 0.25 & -0.85 \\
\end{pmatrix}^{-1}
=
\begin{pmatrix}
0.1476 & 0.3463 & 0.2474 & 0.2588
\end{pmatrix}
La probabilité de chaque type a été calculée. Le code Python est illustré ci-dessous.
import numpy as np
A = np.array(
[[0.05, 0.25, 0.45, 0.25],
[0.15, 0.20, 0.30, 0.35],
[0.20, 0.50, 0.05, 0.25],
[0.15, 0.45, 0.25, 0.15]]
)
A -= np.identity(4) #Transition
A[:, 0] = 1 #Condition a+b+c+d=Mettre 1
B = np.array([1, 0, 0, 0])
print(B @ np.linalg.inv(A)) # [0.1476074 0.34627733 0.24736279 0.25875248]
Pour atteindre la valeur maximale (660 cloches), en plus de "3. Grand rebond" (probabilité 0,2474), les conditions suivantes sont requises.
R: Le prix d'achat de l'île (le prix que vous pouvez acheter à Uri le dimanche matin) est de 90 à 110 cloches, soit 110 cloches. </ b> B: Aux heures de pointe, ce sera 2 à 6 fois le prix d'achat, mais ce sera 6 fois. </ b>
Pour A, il est aléatoire (randint à la ligne 123 du code) et la probabilité est $ \ frac {1} {21} $. Pour B, commencez par générer une valeur numérique de type flottant de 2,0 à 6,0 sous forme d'agrandissement, mais le prix de pointe n'est pas exactement 6,0 fois car il est le résultat de (prix d'achat) × (grossissement) arrondi après la virgule décimale. Il est possible que ce soit le cas. L'agrandissement est déterminé en fonction d'un nombre aléatoire de type uint32_t (prend une valeur entière de $ 0 $ à $ 2 ^ {32} $), et plus la valeur aléatoire est élevée, plus l'agrandissement est important. Par conséquent, la probabilité de satisfaire la condition B est obtenue en examinant la frontière du nombre aléatoire de type uint32_t dont le prix de pointe est de 660 cloches en utilisant une dichotomie.
#include <bits/stdc++.h>
using namespace std;
// uint32_Une fonction qui renvoie un nombre de type flottant basé sur un nombre aléatoire de type t. Plus le nombre aléatoire est grand, plus b est proche.
float randfloat(float a, float b, uint32_t u32)
{
uint32_t val = 0x3F800000 | (u32 >> 9);
float fval = *(float *)(&val);
return a + ((fval - 1.0f) * (b - a));
}
//Fonction d'arrondi après la virgule décimale
int intceil(float val)
{
return (int)(val + 0.99999f);
}
int main() {
uint32_t ll = 0; //uint32_Limite inférieure de t
uint32_t rr = pow(2, 32) - 1; //uint32_Limite supérieure de t
int32_t basePrice = 110; //Prix d'achat
uint64_t l, r, m;
int32_t peakPrice;
l = 0;
r = pow(2, 32) - 1;
m = (l + r) / 2;
//Recherche de bisection
while (r - l > 1) {
peakPrice = intceil(randfloat(2.0, 6.0, m) * basePrice); //Prix de pointe
if (peakPrice < 660) {l = m;}
else {r = m;}
m = (l + r) / 2;
}
cout << 0 << "De" << rr << "Le nombre aléatoire qui prend la valeur de" << m << "S'il est plus grand, ce sera la valeur la plus élevée." << endl;
cout << "La probabilité est" << (double)(rr - m) / (double)(rr) << "Est." << endl;
}
production
Si le nombre aléatoire compris entre 0 et 4294967295 est supérieur à 4285206015, il s'agit de la valeur la plus élevée.
La probabilité est de 0.C'est 00227273.
Multiplier toutes les probabilités calculées donne 0,2474 $ \ fois \ frac {1} {21} \ fois 0,002272 = 2,68 \ fois 10 ^ {-5} $. Bien qu'il s'agisse d'une faible probabilité de 0,00268% </ b>, le nombre de jeux vendus est de <a href = "https://www.nintendo.co.jp/ir/pdf/2020/" au 7 mai 2020. 200507_3.pdf "> 11,77 millions de bouteilles , donc même si 1% d’entre elles vérifient le prix du petit, environ 3 personnes dans le monde vérifient le prix le plus élevé de 660 cloches chaque semaine. Cela devient le calcul qui se fait.
Ensuite, calculons la probabilité du prix le plus bas.
Afin d'atteindre le prix le plus bas (9 cloches), en plus de "4. Bounce small size" (probabilité 0,2588), les conditions suivantes sont requises.
R: Le prix d'achat de l'île (le prix que vous pouvez acheter à Uri le dimanche matin) est de 90 à 110 cloches, soit 90 cloches. </ b> B: Des huit "temps pour commencer à augmenter pour la première fois" {lundi matin, lundi après-midi, ..., jeudi après-midi}, lundi matin ou jeudi après-midi. </ b>
Puisque A et B sont sélectionnés par des nombres aléatoires, les probabilités sont respectivement $ \ frac {1} {21} et \ frac {1} {4} $. Pour C, commencez par générer une valeur de type flottant de 0,4 à 0,9 comme un grossissement, et multipliez-la par 90 cloches du prix d'achat pour obtenir le prix du petit lundi matin. Étant donné que les fractions sous la virgule décimale sont arrondies, le grossissement doit être de 0,4 (une légère augmentation n'est pas un problème en raison de l'erreur) pour atteindre 36 cloches. Comme mentionné ci-dessus, le grossissement est déterminé en fonction du nombre aléatoire de type uint32_t (prend une valeur entière de $ 0 $ à $ 2 ^ {32} $), mais ici, plus la valeur aléatoire est petite, plus le grossissement est grand. (Ligne de code 317). Après tout, il semble bon de trouver la probabilité que la condition C soit satisfaite en examinant la frontière d'un nombre aléatoire avec une valeur cub de 36 cloches en utilisant une dichotomie.
#include <bits/stdc++.h>
using namespace std;
// uint32_Une fonction qui renvoie un nombre de type flottant basé sur un nombre aléatoire de type t. Plus le nombre aléatoire est grand, plus b est proche.
float randfloat(float a, float b, uint32_t u32)
{
uint32_t val = 0x3F800000 | (u32 >> 9);
float fval = *(float *)(&val);
return a + ((fval - 1.0f) * (b - a));
}
//Fonction d'arrondi après la virgule décimale
int intceil(float val)
{
return (int)(val + 0.99999f);
}
int main() {
uint32_t ll = 0; //uint32_Limite inférieure de t
uint32_t rr = pow(2, 32) - 1; //uint32_Limite supérieure de t
int32_t basePrice = 90; //Prix d'achat
uint64_t l, r, m;
int32_t monAmPrice;
l = 0;
r = pow(2, 32) - 1;
m = (l + r) / 2;
//Recherche de bisection
while (r - l > 1) {
monAmPrice = intceil(randfloat(0.9, 0.4, m) * basePrice); //Prix du lundi matin
if (monAmPrice > 36) {l = m;}
else {r = m;}
m = (l + r) / 2;
}
cout << ll << "De" << rr << "Le nombre aléatoire qui prend la valeur de" << m << "S'il est supérieur à, la condition C est satisfaite." << endl;
cout << "La probabilité est" << (double)(rr - m) / (double)(rr) << "Est." << endl;
}
production
La condition C est satisfaite si le nombre aléatoire compris entre 0 et 4294967295 est supérieur à 4294966783.
La probabilité est de 1.19209e-07.
En raison de la nature de l'arrondissement après la virgule décimale, la probabilité est cette fois nettement inférieure à la condition B à la valeur la plus élevée.
Enfin, considérons la probabilité de satisfaire à la condition «D: le prix du petit jeudi après-midi peut être de 9 à 65 cloches, soit 9 cloches». Le ratio de 0,4 à partir du lundi matin diminue de manière monotone pendant les six périodes du lundi après-midi au jeudi après-midi. À ce moment, dans chaque période, la quantité de diminution du grossissement est déterminée de 0,03 à 0,05 et mise à jour. Pour que 90 cloches deviennent 9 cloches, le rapport doit être de 0,1 $ = 0,4-0,05 \ fois 6 $, et nous considérerons le cas où le taux de déclin est presque le maximum (0,05) pendant 6 périodes consécutives. Cependant, lors de l'arrondi de la valeur cub après la virgule décimale, le processus "d'ajout de 0,9999 puis de tronquage de la fraction" est effectué, par exemple, la cloche 9,001 est arrondie à 10 cloches, mais la cloche 9,0000001 devient 9 cloches. Faire. Par conséquent, il est possible que le taux de déclin ne doive pas être la valeur maximale pour les six fois. Même ainsi, dans la condition C, la valeur seuil du nombre aléatoire a été obtenue en effectuant une dichotomie, mais cela a été possible car le nombre aléatoire n'a été généré qu'une seule fois, et cette fois 6 nombres aléatoires sont impliqués, donc simplement Ne peux pas. Par conséquent, la probabilité est calculée par la méthode suivante.
D-1. Soit $ A $ le taux de déclin (le plus proche de 0,03 (Note)) lorsque le nombre aléatoire est la valeur la plus élevée de 2 $ ^ {32} -1 $. À la condition que le montant de la baisse de 5 fois sur 6 soit de $ A $, le seuil de combien ou plus de la diminution restante sera de 9 cloches est calculé. Soit le seuil de $ B $. D-2 Pour le montant de la diminution de $ B $ à $ A $, trouvez la plage du nombre aléatoire comme étant le montant de la diminution. D-3. Recherchez dans chacune des 6 gouttes entre $ B $ et $ A $, et pour celles avec 9 cloches, le nombre de ces cas (multipliez la largeur obtenue par D-2 par 6) Additionner). D-4. La valeur divisée par $ (2 ^ {32}) ^ 6 $ est la probabilité de satisfaire la condition D.
(Note) La raison pour laquelle il est de 0,03 au lieu de 0,05 est que l'opération de «soustraire 0,02 puis soustraire 0 à 0,03» est effectuée dans l'analyse, et cela suit.
Quant à la quantité de déclin, il est plus facile à gérer en regardant la partie incorrecte de type flottant que d'afficher la partie décimale en décimal, donc elle est écrite comme telle. Je me suis référé à l'article suivant pour obtenir la représentation hexadécimale de la pièce incorrecte. https://qiita.com/nia_tn1012/items/d26f0fc993895a09b30b De plus, la valeur du nombre aléatoire, qui était auparavant exprimée en décimal, sera désormais exprimée en hexadécimal.
Tout d'abord, effectuez D-1 par dichotomie.
#include <bits/stdc++.h>
using namespace std;
// uint32_Une fonction qui renvoie un nombre de type flottant basé sur un nombre aléatoire de type t. Plus le nombre aléatoire est grand, plus b est proche.
float randfloat(float a, float b, uint32_t u32)
{
uint32_t val = 0x3F800000 | (u32 >> 9);
float fval = *(float *)(&val);
return a + ((fval - 1.0f) * (b - a));
}
//Fonction d'arrondi après la virgule décimale
int intceil(float val)
{
return (int)(val + 0.99999f);
}
//Une fonction qui retourne la partie formelle du type float
int printb(float ff) {
union { float f; int i; } a;
int i;
a.f = ff;
return a.i & 0x7FFFFF;
}
int main() {
uint32_t ll = 0; //uint32_Limite inférieure de t
uint32_t rr = pow(2, 32) - 1; //uint32_Limite supérieure de t
int32_t basePrice = 90; //Prix d'achat
uint64_t l, r, m;
float declineRate;
int32_t thuPmPrice;
l = 0;
r = pow(2, 32) - 1;
m = (l + r) / 2;
//Recherche de bisection
while (r - l > 1) {
declineRate = (0.4 - 0.03 * 6 - randfloat(0, 0.02, rr) * 5 - randfloat(0, 0.02, m));
thuPmPrice = intceil(declineRate * basePrice); //Prix jeudi après-midi
if (thuPmPrice > 9) {l = m;}
else {r = m;}
m = (l + r) / 2;
}
cout << hex << "La partie incorrecte de la largeur de chute B est" << printb(randfloat(0, 0.02, m+1)) \
<< "Et la valeur du plus petit nombre aléatoire dans la plage de déclin est" << m+1 << "Est." << endl;
cout << hex << "La partie incorrecte de la largeur de chute A est" << printb(randfloat(0, 0.02, rr)) << "Est." << endl;
}
production
La partie formelle de la largeur de chute B est 23d6db, et la plus petite valeur aléatoire de la largeur de chute est ffffb600.
La partie incorrecte de la largeur de chute A est 23d709.
Par conséquent, vous pouvez rechercher 23d6db à 23d709, mais juste au cas où, vérifiez 48 chemins de 23d6da à 23d709. (Selon l'ordre de calcul, la partie formelle peut chuter à 9 cloches même avec une baisse de 23d6da en raison d'une erreur d'arrondi)
Ensuite, J-2 à J-4 ont été réalisés en une seule fois. Le temps de calcul a pris environ 10 minutes.
#include <bits/stdc++.h>
using namespace std;
// uint32_Une fonction qui renvoie un nombre de type flottant basé sur un nombre aléatoire de type t. Plus le nombre aléatoire est grand, plus b est proche.
float randfloat(float a, float b, uint32_t u32)
{
uint32_t val = 0x3F800000 | (u32 >> 9);
float fval = *(float *)(&val);
return a + ((fval - 1.0f) * (b - a));
}
//Fonction d'arrondi après la virgule décimale
int intceil(float val)
{
return (int)(val + 0.99999f);
}
//Une fonction qui retourne la partie formelle du type float
int printb(float ff) {
union { float f; int i; } a;
int i;
a.f = ff;
return a.i & 0x7FFFFF;
}
//Une fonction récursive qui recherche toutes les manières dont le grossissement diminue
int64_t fullSearch(float declineRateNow, int step, int basePrice, vector<float> declineRates, int c) {
int64_t ans = 0;
int32_t thuPmPrice;
if (step == 6) {
thuPmPrice = intceil(declineRateNow * basePrice); //Vérifiez si le prix le jeudi après-midi est de 9 cloches
if (thuPmPrice == 9) {return 1;}
else {return 0;}
}
else {
declineRateNow -= 0.03;
for (int i=0; i<c; i++) {
ans += fullSearch(declineRateNow - declineRates.at(i), step + 1, basePrice, declineRates, c);
}
}
return ans;
}
int main() {
uint32_t m = pow(2, 32) - 1;
float declineRate = randfloat(0, 0.02, m);
float declineRate_b = randfloat(0, 0.02, m);
uint32_t l, r;
int c = 0;
vector<float> declineRates(50);
// D-2
r = m;
cout << "No. |Limite inférieure aléatoire|Limite supérieure aléatoire|largeur|Fausse partie du montant de la baisse" << endl;
while (true) {
declineRate_b = declineRate;
declineRate = randfloat(0, 0.02, m);
if (printb(declineRate) < printb(declineRate_b)) {
l = m + 1;
cout << hex << setfill('0') << setw(2) << c << " | " << l << " | " << r << " | " \
<< r-l+1 << " | " << printb(declineRate_b) << endl;
declineRates.at(c) = declineRate_b;
r = m;
c++;
if (printb(declineRate) < 0x23d6da) {break;}
}
m--;
}
// D-3
int32_t basePrice = 90;
int64_t count9bell = fullSearch(0.4, 0, basePrice, declineRates, c);
// D-4
// (2^9)^Après avoir multiplié par 6(2^32)^23 par 2 au lieu de diviser par 6*Divisé 6 fois
double prob_d = count9bell;
for (int i=0; i<23*6; i++) {
prob_d /= 2;
}
cout << dec << "37^Parmi les 6 façons de réduire le grossissement, celle avec un petit prix de 9 cloches" << count9bell << "C'est une rue." << endl;
cout << "Dans ce cas, la condition D est satisfaite et la probabilité est" << prob_d << "Est." << endl;
}
Tout d'abord, en D-2, nous avons calculé la plage de chute dans laquelle la partie aléatoire est de 23d6da à 23d709, soit 48 voies, et la plage de chute. La sortie suivante a été obtenue.
No. |Limite inférieure aléatoire|Limite supérieure aléatoire|largeur|Fausse partie du montant de la baisse
00 | fffffe00 | ffffffff | 200 | 23d709
01 | fffffc00 | fffffdff | 200 | 23d707
02 | fffffa00 | fffffbff | 200 | 23d706
03 | fffff800 | fffff9ff | 200 | 23d705
04 | fffff600 | fffff7ff | 200 | 23d704
05 | fffff400 | fffff5ff | 200 | 23d702
06 | fffff200 | fffff3ff | 200 | 23d701
07 | fffff000 | fffff1ff | 200 | 23d700
08 | ffffee00 | ffffefff | 200 | 23d6fe
09 | ffffec00 | ffffedff | 200 | 23d6fd
0a | ffffea00 | ffffebff | 200 | 23d6fc
0b | ffffe800 | ffffe9ff | 200 | 23d6fb
0c | ffffe600 | ffffe7ff | 200 | 23d6f9
0d | ffffe400 | ffffe5ff | 200 | 23d6f8
0e | ffffe200 | ffffe3ff | 200 | 23d6f7
0f | ffffe000 | ffffe1ff | 200 | 23d6f6
10 | ffffde00 | ffffdfff | 200 | 23d6f4
11 | ffffdc00 | ffffddff | 200 | 23d6f3
12 | ffffda00 | ffffdbff | 200 | 23d6f2
13 | ffffd800 | ffffd9ff | 200 | 23d6f0
14 | ffffd600 | ffffd7ff | 200 | 23d6ef
15 | ffffd400 | ffffd5ff | 200 | 23d6ee
16 | ffffd200 | ffffd3ff | 200 | 23d6ed
17 | ffffd000 | ffffd1ff | 200 | 23d6eb
18 | ffffce00 | ffffcfff | 200 | 23d6ea
19 | ffffcc00 | ffffcdff | 200 | 23d6e9
1a | ffffca00 | ffffcbff | 200 | 23d6e7
1b | ffffc800 | ffffc9ff | 200 | 23d6e6
1c | ffffc600 | ffffc7ff | 200 | 23d6e5
1d | ffffc400 | ffffc5ff | 200 | 23d6e4
1e | ffffc200 | ffffc3ff | 200 | 23d6e2
1f | ffffc000 | ffffc1ff | 200 | 23d6e1
20 | ffffbe00 | ffffbfff | 200 | 23d6e0
21 | ffffbc00 | ffffbdff | 200 | 23d6de
22 | ffffba00 | ffffbbff | 200 | 23d6dd
23 | ffffb800 | ffffb9ff | 200 | 23d6dc
24 | ffffb600 | ffffb7ff | 200 | 23d6db
Tous les nombres du tableau sont hexadécimaux. Par exemple, si vous regardez la dernière ligne, si vous prenez des valeurs 0x200 de ffffb600 à ffffb7ff (nombres aléatoires prenant des valeurs de 00000000 à ffffffff), la partie incorrecte du montant de la baisse sera 23d6db. À partir de ce tableau, nous pouvons voir ce qui suit.
Par conséquent, pour J-3 et J-4, nous avons recherché les 6 périodes de déclin de ces 37 façons, et compté le nombre de fois où le prix du louveteau est devenu 9 cloches dans le schéma de déclin de 37 $ ^ 6 $, et le nombre de fois. Multiplié par $ (2 ^ 9) ^ 6 $ puis divisé par $ (2 ^ {32}) ^ 6 $, la condition "D: le prix du petit jeudi après-midi peut être de 9 à 65 cloches" Cependant, c'est 9 cloches. " À la suite de ce calcul, la sortie suivante a été obtenue.
37^Sur les 6 "comment réduire le grossissement", 8689156 ont un prix cubique de 9 cloches.
Dans ce cas, la condition D est remplie et la probabilité est de 2.49367e-Il est 035.
En multipliant la probabilité de fluctuation (petit rebond) et la probabilité des conditions A à D, $ 0,2588 \ times \ frac {1} {21} \ times \ frac {1} {4} \ times (1,192 \ times 10 ^ {-7}) \ times (2,494 \ times 10 ^ {-35}) = 9,16 \ fois 10 ^ {-45} $. C'est une faible probabilité astronomique. Même si les 7,7 milliards de personnes vivant sur terre ont ce jeu et vérifient le prix du louveteau chaque semaine depuis la naissance de l'univers il y a 13,8 milliards d'années jusqu'à nos jours, même une fois qu'ils voient "1 cub 9 bell" La probabilité d'être fait est de 5,08 $ \ fois 10 ^ {-23} $. </ b> Il convient de noter que c'est la probabilité que le code source du résultat de l'analyse de l'algorithme de détermination de la valeur cubique décrit dans la «prémisse» soit complètement le même que celui à l'intérieur du jeu. Si la valeur ajoutée par la fonction intceil arrondie après la virgule décimale est de 0,999999 au lieu de 0,99999, la probabilité du prix le plus bas sera plus faible, et même si le type flottant est de type double, la probabilité changera.
Outil de prévision des prix des louveteaux de la forêt des animaux Atsumare | hyperWiki Lorsque vous entrez le prix d'achat ou de vente du petit, la valeur prévue du prix du petit et la probabilité que le prix du petit soit dans chaque modèle de fluctuation sont affichées.
Test de code AtCoder Page de test de code du site de programmation de compétition AtCoder. Même si le japonais est utilisé pour la sortie standard de C ++, il est émis sans caractères déformés.
Recommended Posts