Optimisation script

[Peugeot203]

Bonjour à tous et toutes,

Je souhaiterai optimiser mon script, mais je ne sais pas comment faire :

 a1 = math.Round( math.Rand( 1, 2 ),2 ) a2 = math.Round( math.Rand( 1, 2 ),2 ) a3= math.Round( math.Rand( 1, 2 ),2 ) a4 math.Round( math.Rand( 1, 2 ),2 ) a5= math.Round(math.Rand( 1, 2 ),2) a6 = math.Round(math.Rand( 1, 2 ),2) b1 = math.Round( math.Rand( 1, 2 ),2 ) b2 = math.Round( math.Rand( 1, 2 ),2 ) b3 = math.Round( math.Rand( 1, 2 ) ,2 ) b4 = math.Round( math.Rand(1, 2 ),2 ) b5 = math.Round(math.Rand( 1, 2 ), 2) b6 = math.Round(math.Rand( 1, 2 ),2) b7 = math.Round( math.Rand( 1, 2 ),2 ) b8= math.Round( math.Rand( 1, 2 ), 2 )

J'ai essayé ça :

local tbltest {a1, a2, a3,a4, a5, a6, b1, b2,b3, b4, b5,b6,b7,b8}
for k, v in pairs(tbltest) do
v = math.Round(math.Rand(1,2),2)
end
print(a1)
Output : nil

Il y a t-il un autre moyen de le faire s'il vous plait ?

Cordialement, peugeot203

 

[Deadman69330]

Déjà pourquoi faire un "math.round" sur un random entre 1 et 2 ?
Ca te donnera que 1 ou 2 donc un nombre déjà arrondis

 

[Peugeot203]

Déjà pourquoi faire un "math.round" sur un random entre 1 et 2 ?
Ca te donnera que 1 ou 2 donc un nombre déjà arrondis

Garry's Mod Wiki

Welcome to the Garry's Mod Wiki. Here you will find tutorials, resources and documentation about Garry's Mod and its Lua API. The wiki is a public resource and maintained by Facepunch and the community. Want to make your own changes to the wiki? Chec..

wiki.garrysmod.com

 

[chatom_]

J'ai pas réussi à faire ca avec une table, mais remplace déjà math.rand() pars math.random() (pour des entiers)

Garry's Mod Wiki

Welcome to the Garry's Mod Wiki. Here you will find tutorials, resources and documentation about Garry's Mod and its Lua API. The wiki is a public resource and maintained by Facepunch and the community. Want to make your own changes to the wiki? Chec..

wiki.garrysmod.com

 

[Peugeot203]

J'ai pas réussi à faire ca avec une table, mais remplace déjà math.rand() pars math.random() (pour des entiers)

Garry's Mod Wiki

Welcome to the Garry's Mod Wiki. Here you will find tutorials, resources and documentation about Garry's Mod and its Lua API. The wiki is a public resource and maintained by Facepunch and the community. Want to make your own changes to the wiki? Chec..

wiki.garrysmod.com

Justement , je ne veux pas d'entiers ^^'

 

[Nordahl_of_zworld]

Hey Bonjour,

Dans quoi se situe le code? Une boucle? parce qu'il y a beaucoup de solutions à sa situation.

Pour commencer dans la première solution :

Et il y a une erreur à a4, il manque un = ça ne peut pas fonctionner sans la corriger.

Donc :

a4 = math.Round(math.Rand(1,2),2)

Autrement a5 a6 b1 b2 b3 b4 b5 b6 b7 b8 retournera un 'nil'

Avec le code corrigé la première solution dans mon systeme de StressTest elle freeze mon serveur pendant 0.0033Sec quand lancé 10 000 fois(c'est un résultat correct, ça s'appel un Stress test. Les données données que l'on en tire permet de prendre les meilleurs décisions possible, c'est cool pour découvrir un environnement et de connaitre ses limites).

___________________________________________________________________________

Ensuite dans votre deuxième solution avec la table il y a aussi une erreur à tbltest il manque un = là c'est pas viable non plus si ce n'est pas corrigé.

Donc si je corrige on obtient :

local tbltest = {a1=0, a2=0, a3=0,a4=0, a5=0, a6=0, b1=0, b2=0,b3=0, b4=0, b5=0,b6=0,b7=0,b8=0}
for k, v in pairs(tbltest) do
tbltest[v] = math.Round(math.Rand(1,2),2)
end

print(tbltest['a1'])//1.58


Avec le code corrigé la deuxième solution lancé 10 000 fois donne un score de Score: 0.0159Sec. Un tel score augmente l'utilisation du CPU et tous les services du serveur peuvent être ralenti donc une augmentation du ping chez les joueurs. Si le code est installé coté serveur c'est des FPS qu'il va perdre.

** Petit Pause Café **

Si on compare les scores : 0.0192/ 0.0033=5.8

La première solution est 5.8 fois plus rapide que la deuxième solutin avec la table

------------------------------------------------------------------------------------------

En expérimentant une 3ème méthode pour la curiosité de tous en continuant d'utiliser la table, cet fois je veux qu'elle est un index numérique :

tbltest = {0, 0, 0,0, 0, 0, 0, 0,0, 0, 0,0,0,0}
for k, v in pairs(tbltest) do
tbltest[k] = math.Round(math.Rand(1,2),2)
end

print(tbltest[1])//1.77

Lancé 10 000 fois j'ai un un score de 0.0047Sec. 0.0047/0.0033=1.4.
La première solution gagne toujours car 1.4 fois plus rapide.

------------------------------------------------------------------------------------------

Et avec une 4ème méthode un peu brute et minifié (Voir la minification : Minification — Wikipédia)
Ici vous avez aussi une table.

local t={0,0,0,0,0,0,0,0,0,0,0,0,0,0}
local q,m1,m2=#t,math.Round,math.Rand
for val=1,q do t[val]=m1(m2(1,2),2)end

print(t[1]) //1.18

Lancé 10 000 fois j'ai un score de 0.0034 ce qui est bon car on a une table comem vous semblez souhaiter.

------------------------------------------------------------------------------------------

La pire est celle là :

local t={}
local q,m1,m2=#t,math.Round,math.Rand
for val = 1, 14 do t['a'..i]=m1(m2(1,2),2)end

print(t["a1"]) //1.48

Lancé 10 000 fois = 0.1126Sec

Donc on divise par le meilleurs score pour obtenir un multiplicateur 0.1126/0.0033=34.12

34.12 fois plus lourde.

--------------------

Si vous avez d'autres solutions je suis aussi curieux de les tester et de vous retourner les scores. Car si le test est fait depuis une meilleurs ou une moins bonne machine le score sera tout simplement plus ou moins rapide. Gardons ma machine comme référence.

à vous de choisir,

Cordialement,

 

[Shaar]

Hey Bonjour,

Dans quoi se situe le code? Une boucle? parce qu'il y a beaucoup de solutions à sa situation.

Pour commencer dans la première solution :

Et il y a une erreur à a4, il manque un = ça ne peut pas fonctionner sans la corriger.

Donc :

a4 = math.Round(math.Rand(1,2),2)

Autrement a5 a6 b1 b2 b3 b4 b5 b6 b7 b8 retournera un 'nil'

Avec le code corrigé la première solution dans mon systeme de StressTest elle freeze mon serveur pendant 0.0033Sec quand lancé 10 000 fois(c'est un résultat correct, ça s'appel un Stress test. Les données données que l'on en tire permet de prendre les meilleurs décisions possible, c'est cool pour découvrir un environnement et de connaitre ses limites).

___________________________________________________________________________

Ensuite dans votre deuxième solution avec la table il y a aussi une erreur à tbltest il manque un = là c'est pas viable non plus si ce n'est pas corrigé.

Donc si je corrige on obtient :

local tbltest = {a1=0, a2=0, a3=0,a4=0, a5=0, a6=0, b1=0, b2=0,b3=0, b4=0, b5=0,b6=0,b7=0,b8=0}
for k, v in pairs(tbltest) do
tbltest[v] = math.Round(math.Rand(1,2),2)
end

print(tbltest['a1'])//1.58


Avec le code corrigé la deuxième solution lancé 10 000 fois donne un score de Score: 0.0159Sec. Un tel score augmente l'utilisation du CPU et tous les services du serveur peuvent être ralenti donc une augmentation du ping chez les joueurs. Si le code est installé coté serveur c'est des FPS qu'il va perdre.

** Petit Pause Café**

Si on compare les scores : 0.0192/ 0.0033=5.8

La première solution est 5.8 fois plus rapide que la deuxième solutin avec la table

------------------------------------------------------------------------------------------

En expérimentant une 3ème méthode pour la curiosité de tous en continuant d'utiliser la table, cet fois je veux qu'elle est un index numérique :

tbltest = {0, 0, 0,0, 0, 0, 0, 0,0, 0, 0,0,0,0}
for k, v in pairs(tbltest) do
tbltest[k] = math.Round(math.Rand(1,2),2)
end

print(tbltest[1])//1.77

Lancé 10 000 fois j'ai un un score de 0.0047Sec. 0.0047/0.0033=1.4.
La première solution gagne toujours car 1.4 fois plus rapide.

------------------------------------------------------------------------------------------

Et avec une 4ème méthode un peu brute et minifié (Voir la minification : Minification — Wikipédia)
Ici vous avez aussi une table.

local t={0,0,0,0,0,0,0,0,0,0,0,0,0,0}
local q,m1,m2=#t,math.Round,math.Rand
for val=1,q do t[val]=m1(m2(1,2),2)end

print(t[1]) //1.18

Lancé 10 000 fois j'ai un score de 0.0034 ce qui est bon car on a une table comem vous semblez souhaiter.

------------------------------------------------------------------------------------------

La pire est celle là :

local t={}
local q,m1,m2=#t,math.Round,math.Rand
for val = 1, 14 do t['a'..i]=m1(m2(1,2),2)end

print(t["a1"]) //1.48

Lancé 10 000 fois = 0.1126Sec

Donc on divise par le meilleurs score pour obtenir un multiplicateur 0.1126/0.0033=34.12

34.12 fois plus lourde.

--------------------

Si vous avez d'autres solutions je suis aussi curieux de les tester et de vous retourner les scores. Car si le test est fait depuis une meilleurs ou une moins bonne machine le score sera tout simplement plus ou moins rapide. Gardons ma machine comme référence.

à vous de choisir,

Cordialement,

cette methode me prend un peut moins de lua memory et un peut plus rapide pour moi math.random( 100 , 200 )/100

local t , m = SysTime() , collectgarbage("count")
for i=1,10000 do local a1 = math.Round( math.Rand( 1, 2 ),2) local a2 = math.Round( math.Rand( 1, 2 ),2) local a3 = math.Round( math.Rand( 1, 2 ),2) local a4 = math.Round( math.Rand( 1, 2 ),2) local a5 = math.Round( math.Rand( 1, 2 ),2) local a6 = math.Round( math.Rand( 1, 2 ),2) local b1 = math.Round( math.Rand( 1, 2 ),2) local b2 = math.Round( math.Rand( 1, 2 ),2) local b3 = math.Round( math.Rand( 1, 2 ),2) local b4 = math.Round( math.Rand( 1, 2 ),2) local b5 = math.Round( math.Rand( 1, 2 ),2) local b6 = math.Round( math.Rand( 1, 2 ),2) local b7 = math.Round( math.Rand( 1, 2 ),2) local b8 = math.Round( math.Rand( 1, 2 ),2)
end
print( SysTime() - t , collectgarbage("count") - m )
local t , m = SysTime() , collectgarbage("count")
for i=1,10000 do local a1 = math.random( 100 , 200 )/100 local a2 = math.random( 100 , 200 )/100 local a3 = math.random( 100 , 200 )/100 local a4 = math.random( 100 , 200 )/100 local a5 = math.random( 100 , 200 )/100 local a6 = math.random( 100 , 200 )/100 local b1 = math.random( 100 , 200 )/100 local b2 = math.random( 100 , 200 )/100 local b3 = math.random( 100 , 200 )/100 local b4 = math.random( 100 , 200 )/100 local b5 = math.random( 100 , 200 )/100 local b6 = math.random( 100 , 200 )/100 local b7 = math.random( 100 , 200 )/100 local b8 = math.random( 100 , 200 )/100
end
print( SysTime() - t , collectgarbage("count") - m )

http://imgur.com/45fgBVf

 

[Peugeot203]

Hey Bonjour,

Dans quoi se situe le code? Une boucle? parce qu'il y a beaucoup de solutions à sa situation.

Pour commencer dans la première solution :

Et il y a une erreur à a4, il manque un = ça ne peut pas fonctionner sans la corriger.

Donc :

a4 = math.Round(math.Rand(1,2),2)

Autrement a5 a6 b1 b2 b3 b4 b5 b6 b7 b8 retournera un 'nil'

Avec le code corrigé la première solution dans mon systeme de StressTest elle freeze mon serveur pendant 0.0033Sec quand lancé 10 000 fois(c'est un résultat correct, ça s'appel un Stress test. Les données données que l'on en tire permet de prendre les meilleurs décisions possible, c'est cool pour découvrir un environnement et de connaitre ses limites).

___________________________________________________________________________

Ensuite dans votre deuxième solution avec la table il y a aussi une erreur à tbltest il manque un = là c'est pas viable non plus si ce n'est pas corrigé.

Donc si je corrige on obtient :

local tbltest = {a1=0, a2=0, a3=0,a4=0, a5=0, a6=0, b1=0, b2=0,b3=0, b4=0, b5=0,b6=0,b7=0,b8=0}
for k, v in pairs(tbltest) do
tbltest[v] = math.Round(math.Rand(1,2),2)
end

print(tbltest['a1'])//1.58


Avec le code corrigé la deuxième solution lancé 10 000 fois donne un score de Score: 0.0159Sec. Un tel score augmente l'utilisation du CPU et tous les services du serveur peuvent être ralenti donc une augmentation du ping chez les joueurs. Si le code est installé coté serveur c'est des FPS qu'il va perdre.

** Petit Pause Café**

Si on compare les scores : 0.0192/ 0.0033=5.8

La première solution est 5.8 fois plus rapide que la deuxième solutin avec la table

------------------------------------------------------------------------------------------

En expérimentant une 3ème méthode pour la curiosité de tous en continuant d'utiliser la table, cet fois je veux qu'elle est un index numérique :

tbltest = {0, 0, 0,0, 0, 0, 0, 0,0, 0, 0,0,0,0}
for k, v in pairs(tbltest) do
tbltest[k] = math.Round(math.Rand(1,2),2)
end

print(tbltest[1])//1.77

Lancé 10 000 fois j'ai un un score de 0.0047Sec. 0.0047/0.0033=1.4.
La première solution gagne toujours car 1.4 fois plus rapide.

------------------------------------------------------------------------------------------

Et avec une 4ème méthode un peu brute et minifié (Voir la minification : Minification — Wikipédia)
Ici vous avez aussi une table.

local t={0,0,0,0,0,0,0,0,0,0,0,0,0,0}
local q,m1,m2=#t,math.Round,math.Rand
for val=1,q do t[val]=m1(m2(1,2),2)end

print(t[1]) //1.18

Lancé 10 000 fois j'ai un score de 0.0034 ce qui est bon car on a une table comem vous semblez souhaiter.

------------------------------------------------------------------------------------------

La pire est celle là :

local t={}
local q,m1,m2=#t,math.Round,math.Rand
for val = 1, 14 do t['a'..i]=m1(m2(1,2),2)end

print(t["a1"]) //1.48

Lancé 10 000 fois = 0.1126Sec

Donc on divise par le meilleurs score pour obtenir un multiplicateur 0.1126/0.0033=34.12

34.12 fois plus lourde.

--------------------

Si vous avez d'autres solutions je suis aussi curieux de les tester et de vous retourner les scores. Car si le test est fait depuis une meilleurs ou une moins bonne machine le score sera tout simplement plus ou moins rapide. Gardons ma machine comme référence.

à vous de choisir,

Cordialement,

Insane ce que tu nous proposes, merci énormement !

 

[Nordahl_of_zworld]

Peugeot203 C'est dommage que vous ne répondez pas à la première question on pourrait faire mieux en fonction du cas de figure, car pour le moment ignorant à quoi ça sert, je reste à l'idée qu'il est important pour vous que vous souhaitez deux chiffres après la virgule à ce que j'ai compris. Enfin votre première solution que vous souhaitez optimiser semble être la meilleur méthode pour le moment comparé aux autres expériences avec des tables à peaufiner. ^^

Merci Shaar, votre deuxième solution est 1.3x plus rapide, mais niveau PC tu as un meilleurs PC que moi donc nos résultats diffère, j'obtiens 00.22SEC ça reste meilleurs que la première solution, en tout cas merci pour la validation des résultats. En retirant math.Rand( 1, 2 ) c'est encore moins de travail pour le CPU mais il y a un problème, l'utilisateur n'obtient plus les résultats qu'il souhaitait à la sortie, c'est à dire 2 chiffres après la virgule, et le math.Rand(1,2) qu'il a intentionnellement mis servait à ça, mais il existe encore d'autre méthode qui respect le souhait de l'utilisateur.

Je proposerais plutôt :

local mr=math.random //local mr est à placer en haut du fichier ou hors de la boucle mais toujours au dessus.
local mf=math.floor //local mr est à placer en haut du fichier ou hors de la boucle mais toujours au dessus.

local a1 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local a2 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local a3 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local a4 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local a5 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local a6 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b1 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b2 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b3 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b4 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b5 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b6 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b7 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b8 = mf( (mr() + 1) * 100 + 0.5 ) / 100
print(a1) // 1.45

J'obtiens un résultat de 0.0022SEC lancé 10 000 fois. On obtient donc deux chiffres après la virgule totu comme désirait l'utilisateur. Et c'est 1.3x plus optimisé que la meilleurs méthodes de base dans la solution numéro une.

________________________________

Si la quantité des chiffres après la virgule n'est pas importante alors :

Juste ça pourrait largement suffir :

local mr=math.random //local mr est à placer en haut du fichier ou hors de la boucle mais toujours au dessus.

local a1 = mr() + 1
local a2 = mr() + 1
local a3 = mr() + 1
local a4 = mr() + 1
local a5 = mr() + 1
local a6 = mr() + 1
local b1 = mr() + 1
local b2 = mr() + 1
local b3 = mr() + 1
local b4 = mr() + 1
local b5 = mr() + 1
local b6 = mr() + 1
local b7 = mr() + 1
local b8 = mr() + 1

print(a1) //1.5090811716906
Score : 0.0022SEC

Bon allez zou c'était méga interressant tout ça on t'as tout donné. Bon courage

 

[Peugeot203]

Peugeot203 C'est dommage que vous ne répondez pas à la première question on pourrait faire mieux en fonction du cas de figure, car pour le moment ignorant à quoi ça sert, je reste à l'idée qu'il est important pour vous que vous souhaitez deux chiffres après la virgule à ce que j'ai compris. Enfin votre première solution que vous souhaitez optimiser semble être la meilleur méthode pour le moment comparé aux autres expériences avec des tables à peaufiner. ^^

Merci Shaar, votre deuxième solution est 1.3x plus rapide, mais niveau PC tu as un meilleurs PC que moi donc nos résultats diffère, j'obtiens 00.22SEC, en tout cas merci pour la validation des résultats, en retirant math.Rand( 1, 2 ) c'est encore moins de travail pour le CPU mais il y a un problème, l'utilisateur n'obtient plus les résultats qu'il souhaitait à la sortie, c'est à dire 2 chiffres après la virgule, et le math.Rand(1,2) qu'il a intentionnellement mis servait à ça, mais il existe encore d'autre méthode qui respect le souhait de l'utilisateur.

Je proposerais plutot :

local mr=math.random //local mr est à placer en haut du fichier ou hors de la boucle mais toujours au dessus.
local mf=math.floor //local mr est à placer en haut du fichier ou hors de la boucle mais toujours au dessus.

local a1 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local a2 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local a3 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local a4 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local a5 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local a6 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b1 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b2 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b3 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b4 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b5 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b6 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b7 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b8 = mf( (mr() + 1) * 100 + 0.5 ) / 100
print(a1) // 1.45

J'obtiens un résultat de 0.0022SEC lancé 10 000 fois. On obtient donc deux chiffres après la virgule totu comme désirait l'utilisateur. Et c'est 1.3x plus optimisé que la meilleurs méthodes de base dans la solution numéro une.

Regarde la pièce jointe 17309

________________________________

Si la quantité des chiffres après la virgule n'est pas importante alors :

Juste ça pourrait largement suffir :

local mr=math.random //local mr est à placer en haut du fichier ou hors de la boucle mais toujours au dessus.

local a1 = mr() + 1
local a2 = mr() + 1
local a3 = mr() + 1
local a4 = mr() + 1
local a5 = mr() + 1
local a6 = mr() + 1
local b1 = mr() + 1
local b2 = mr() + 1
local b3 = mr() + 1
local b4 = mr() + 1
local b5 = mr() + 1
local b6 = mr() + 1
local b7 = mr() + 1
local b8 = mr() + 1

print(a1) //1.5090811716906
Score : 0.0022SEC

Regarde la pièce jointe 17310

Bon allez zou c'était méga interressant tout ça on t'as tout donné. Bon courage

Le code n'est dans aucune boucle uniquement dans une condition du côté serveur, désolé de ne pas avoir répondu !

 

[Shaar]

Le code n'est dans aucune boucle uniquement dans une condition du côté serveur, désolé de ne pas avoir répondu !

les boucles c'est pour test les performance du code

 

[Shaar]

Peugeot203 C'est dommage que vous ne répondez pas à la première question on pourrait faire mieux en fonction du cas de figure, car pour le moment ignorant à quoi ça sert, je reste à l'idée qu'il est important pour vous que vous souhaitez deux chiffres après la virgule à ce que j'ai compris. Enfin votre première solution que vous souhaitez optimiser semble être la meilleur méthode pour le moment comparé aux autres expériences avec des tables à peaufiner. ^^

Merci Shaar, votre deuxième solution est 1.3x plus rapide, mais niveau PC tu as un meilleurs PC que moi donc nos résultats diffère, j'obtiens 00.22SEC ça reste meilleurs que la première solution, en tout cas merci pour la validation des résultats. En retirant math.Rand( 1, 2 ) c'est encore moins de travail pour le CPU mais il y a un problème, l'utilisateur n'obtient plus les résultats qu'il souhaitait à la sortie, c'est à dire 2 chiffres après la virgule, et le math.Rand(1,2) qu'il a intentionnellement mis servait à ça, mais il existe encore d'autre méthode qui respect le souhait de l'utilisateur.

Je proposerais plutôt :

local mr=math.random //local mr est à placer en haut du fichier ou hors de la boucle mais toujours au dessus.
local mf=math.floor //local mr est à placer en haut du fichier ou hors de la boucle mais toujours au dessus.

local a1 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local a2 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local a3 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local a4 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local a5 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local a6 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b1 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b2 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b3 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b4 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b5 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b6 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b7 = mf( (mr() + 1) * 100 + 0.5 ) / 100
local b8 = mf( (mr() + 1) * 100 + 0.5 ) / 100
print(a1) // 1.45

J'obtiens un résultat de 0.0022SEC lancé 10 000 fois. On obtient donc deux chiffres après la virgule totu comme désirait l'utilisateur. Et c'est 1.3x plus optimisé que la meilleurs méthodes de base dans la solution numéro une.

Regarde la pièce jointe 17309

________________________________

Si la quantité des chiffres après la virgule n'est pas importante alors :

Juste ça pourrait largement suffir :

local mr=math.random //local mr est à placer en haut du fichier ou hors de la boucle mais toujours au dessus.

local a1 = mr() + 1
local a2 = mr() + 1
local a3 = mr() + 1
local a4 = mr() + 1
local a5 = mr() + 1
local a6 = mr() + 1
local b1 = mr() + 1
local b2 = mr() + 1
local b3 = mr() + 1
local b4 = mr() + 1
local b5 = mr() + 1
local b6 = mr() + 1
local b7 = mr() + 1
local b8 = mr() + 1

print(a1) //1.5090811716906
Score : 0.0022SEC

Regarde la pièce jointe 17310

Bon allez zou c'était méga interressant tout ça on t'as tout donné. Bon courage

ma méthode obtiens bien 2 chiffres après la virgule

 local a1 = math.random( 100 , 200 )/100 local a2 = math.random( 100 , 200 )/100 local a3 = math.random( 100 , 200 )/100 local a4 = math.random( 100 , 200 )/100 local a5 = math.random( 100 , 200 )/100 local a6 = math.random( 100 , 200 )/100 local b1 = math.random( 100 , 200 )/100 local b2 = math.random( 100 , 200 )/100 local b3 = math.random( 100 , 200 )/100 local b4 = math.random( 100 , 200 )/100 local b5 = math.random( 100 , 200 )/100 local b6 = math.random( 100 , 200 )/100 local b7 = math.random( 100 , 200 )/100 local b8 = math.random( 100 , 200 )/100 print(
a2,
a3,
a4,
a5,
a6,
b1,
b2,
b3,
b4,
b5,
b6,
b7,
b8 )

http://imgur.com/g1hABBc

 

[Nordahl_of_zworld]

Shaar ah oui en effet. Pardon ça m'apprendra à vouloir aller vite.