Nombres premiers et crible d'Ératosthène |
|
Pouvez-vous écrire un programme en Golang qui génère les nombres premiers en utilisant le crible d'Ératosthène ? Pouvez-vous écrire le même programme en javascript ? Pouvez vous programmer la page html qui utilisera ce programme javascript et les résultats devront s'afficher dans un textarea ? |
Réponse de ChatGPT / Code Generator : Voici le résultat : |
Générateur de mots et règles de substitution |
|
On considère un ensemble de mots : E = { a, bc, abc } Ajouter un textarea contenant en entrée les règles de substitution et en utilisant le symbole -> pour écrire ces règles. Ajouter un textarea contenant en entrée l'ensemble E des mots initiaux. Ajouter une entrée numérique pour pouvoir modifier le nombre maximum de règles appliquées qui est actuellement 10. Pouvez-vous afficher à chaque mot générée le nombre minimum de règles de grammaire qui a été appliquées pour le produire, en affichant se nombre juste entre parenthèse et un espace après le mot ? |
Réponse de ChatGPT / Code Generator : Voici le résultat : |
Manipulation des noeuds d'un graphe |
|
| Définissez en javascript la classe Noeud qui hérite de la classe Array, puis définissez-y la méthode 'A(V)' qui prend un argument entier 'V' et qui à pour effet de déplacer le focus sur le fils numéro 'V' du Noeud en le créant s'il n'existe pas.
Ajouter la méthode 'C(L)' où 'L' est un chemin c'est à dire une liste d'entiers, et qui a pour effet de déplacer le focus successivement de fils en fils de fils dont les numéros sont listés dans L Ajoute aux Noeuds l'attribut 'id' qui servira d'identifiant numérique du noeud. Le noeud racine a l'identifiant 1. À chaque création de noeud on incrémente le nombre 'N' de noeuds et on donne comme identifiant du nouveau noeud la valeur de 'N'. Ajouter une méthode 'aff()' qui génère du texte décrivant l'arborescence des Noeuds dont le noeud racine est le noeud lançant la méthode, et contenant l'identifiant 'id' de chaque noeud. Intègrez ce programme dans une page web, ajouter un bouton "Affiche" et un 'textarea' qui va recevoir la représentation textuelle de l'arborescence. Prenez un exemple utilisant chaque méthode Trouver une solution pour pouvoir afficher une arborescence pouvant contenir des boucles, tout en évitant d'avoir à reparcourir tous les noeuds de la classe. Ajoutez aux Noeuds l'attribut 'L' qui désignera un autre noeud ou 'undefined'. Définir la fonction globale 'redirige(r)' où 'r' est un noeud, et qui retourne le dernier noeud avant 'undefined' dans la succession des redirections de l'attribut 'L' des noeuds. Modifier les méthode 'A(v)' et 'C(L)' en intégrant un aspect : À chaque focus sur un noeud 'r', on se redéplace sur 'redirige(r)' avant de poursuivre le traitement des méthodes. Créer une méthode 'affL()' qui est une modification de la méthode 'aff()' en intégrant un aspect : À chaque focus sur un noeud 'r', on se redéplace sur 'redirige(r)' avant de poursuivre le traitement de la méthode. Cela s'applique donc aussi sur chaque focus sur les fils. Définissez une variable globale r qui sera le noeud racine d'attribut 'id=1'. Prenez l'exemple par défaut où 'r' désigne la racine (variable globale 'r') : corrigez les sauts de lignes dans les textarea. Entre les balises <textarea> et </textarea> les sauts de ligne ne doivent pas être marqués par '\n' mais par un réel saut de ligne dans le code. Modifiez le CSS afin que les 'button' et les 'textarea' se mettent successivement à la ligne. |
Réponse de ChatGPT / Code Generator : Voici le résultat : |
Simulation de particules |
|
Théorie : ../../Physique/signalproj5.html Définir une fonction 'f(A,B)' où 'A' et 'B' sont des particules, et qui fait le calcul suivant : 'f(A,B)' calcul la force qui s'exerce sur la particule 'A' et qui s'exerce en négatif sur la particule 'B'. Programmez une procédure 'sommeForce' qui calcule la sommes des forces qui s'exercent sur chaque particule et qui l'enregistre dans l'attribut force de la particule. Programmez une procédure 'calculAccelerationPente' qui pour chaque particule 'p' fait ce qui suit sans mettre à jour les anciennes accélérations : Programmez une procédure 'calculPositionVitesse' qui pour chaque particule 'p' fait ce qui suit : Programmez une procédure 'step' qui exécute trois fois le calcul suivant pour obtenir un résultat plus précis : Programmer une procédure 'update' qui exécute ce qui suit: Répéter indéfiniment ce qui suit : À l'initialisation, translater les vitesses de toutes les particules afin que la vitesse moyenne soit nulle. Ajouter au canvas, un zoom x2 qui puisse être commander par 2 petits boutons en haut, et 4 autres petits boutons avec des symboles de direction pour pouvoir déplacer les coordonnées dans le canvas d'un offset de 100 pixels. |
Réponse de ChatGPT / Code Generator : Voici le résultat : |
Menu contextuel image HTML |
|
Programme JavaScript et HTML Lorsque l'on clique sur la partie visible de l'image, l'image est mise au premier plan et le focus est mis sur cette image. Lorqu'une image à le focus, le coin inférieur droit contient une zone de prise, qui zoom l'image si on fait un clic-glisser sur la zone de prise. Lors des zoom, le rapport x / y doit être respecté Programme une gestion d'évènement sur la page gérant le glisser-déplacer sur une image, en dehors de la zone de prise pour le zoom, qui à pour effet de prendre le focus et de déplacer l'image Créer un bouton qui commande une sauvegarde de la page web dans un fichier cookie. Créer un second bouton qui commande une restauration de la page web à partir du fichier cookie. Au lieu d'utiliser un fichier cookie, utilisez une base IndexDB Le zoom doit respecter les proportions x/y Lorsque d'un click-droit sur une image, le menu contextuel qui apparaît doit avoir une option en plus qui est "Supprimer" et qui permet de supprimer l'image au premier plan sous la souris Remplacez dans le programme l'instruction |
Réponse de ChatGPT / Code Generator : Voici le résultat : |
Simulation d'ondes
|
|
Peux-tu traduire le programme de simulation d'onde ci-dessous en HTML et Javascript ? // onde project main.go
package main
import (
"fmt"
"math"
"sdl2/sdl"
)
const k = 0.2
const N = 512 // Nombre de mailles
var E0 [N][N]float64 // E(x,y,t-dt)
var E1 [N][N]float64 // E(x,y,t)
var E2 [N][N]float64 // E(x,y,t+dt)
var dt = 1.0400 // Intervalle de temps
var t = 0.0 // Temps
var ech = 20000.0
var a = true
func affichePresentation() {
fmt.Println("onde 2D ")
fmt.Println("-----------------------------------------")
fmt.Println("Commandes :")
fmt.Println("Touche espace -> Affiche le temps et l'énergie totale ")
fmt.Println("Touche + -> Augmente l'amplitude ")
fmt.Println("Touche - -> Dminue l'amplitude ")
fmt.Println("Touche a -> Affiche chaque itération / Affiche une itération sur 10")
fmt.Println("Touche echape -> Quitte le programme ")
fmt.Println("-----------------------------------------")
}
func main() {
affichePresentation()
// initialise une fenêtre de fond noire N×N
sdl.Init(sdl.INIT_EVERYTHING)
defer sdl.Quit()
w, _ := sdl.CreateWindow("modèle", 0, 0, N, N, sdl.WINDOW_SHOWN)
defer w.Destroy()
ws, _ := w.GetSurface()
defer ws.Free()
ws.FillRect(&sdl.Rect{0, 0, N, N}, sdl.MapRGB(ws.Format, 0, 0, 0))
/*
wr, _ := sdl.CreateRenderer(w, -1, sdl.RENDERER_ACCELERATED)
defer wr.Destroy()
wr.Clear()
*/
// met à zéro les maillages à l'instant t=0 et t=dt
for x := 0; x < N; x++ {
for y := 0; y < N; y++ {
E0[x][y] = 0.0
E1[x][y] = 0.0
}
}
e0 := &E0 // Variable renomée
e1 := &E1 // Variable renomée
e2 := &E2 // Variable renomée
/*
wr.SetDrawColor(0, 0, 0, 255)
wr.Clear()
wr.SetDrawColor(uint8(250), 0, uint8(250), 255)
wr.DrawPoint(200, 400)
wr.DrawPoint(201, 401)
wr.DrawPoint(202, 402)
wr.Present(
sdl.Delay(1000)
wr.SetDrawColor(uint8(v), 55, 0, 255)
*/
// Boucle sans fin, exécute une infinité de pas
_B := true
for np := 0; _B; np++ {
for _e := sdl.PollEvent(); _e != nil; _e = sdl.PollEvent() {
switch _t := _e.(type) { //
case *sdl.KeyboardEvent:
if _t.Keysym.Sym == sdl.K_ESCAPE {
_B = false
}
if _t.Keysym.Sym == sdl.K_SPACE && _t.State == 1 {
fmt.Printf("Temps: %.0f ", t)
fmt.Println()
}
if _t.Keysym.Sym == sdl.K_KP_PLUS && _t.State == 1 {
ech = ech * 1.2
fmt.Println(math.Round(ech))
}
if _t.Keysym.Sym == sdl.K_KP_MINUS && _t.State == 1 {
ech = ech / 1.2
fmt.Println(math.Round(ech))
}
if _t.Keysym.Sym == sdl.K_a && _t.State == 1 {
a = !a
if a {
fmt.Println("Affiche chaque itération")
} else {
fmt.Println("Affiche une itération sur 10")
}
}
}
}
for x := 1; x < N-1; x++ {
for y := 1; y < N-1; y++ {
e2[x][y] = k*(e1[x+1][y]+e1[x-1][y]+e1[x][y+1]+e1[x][y-1]) + (2-4*k)*e1[x][y] - e0[x][y]
}
}
h := math.Exp(-(t - 300) * (t - 300) / 10000)
e2[N/4][N/4] = (h*math.Sin(t/20) + e2[N/4][N/4]) / (h + 1)
/*
if t < 1 {
e2[N/2][N/2] = 1
}
*/
// Affichage
if a || 0 == int(t)%10 {
for x := 0; x < N; x++ {
for y := 0; y < N; y++ {
v := e2[x][y]
/*
if v < 0 {
wr.SetDrawColor(0, uint8(-v*ech), uint8(-v*ech), 255)
} else {
wr.SetDrawColor(uint8(v*ech), uint8(v*ech), 0, 255)
}
wr.DrawPoint(int32(x), int32(y))
*/
if v < 0 {
ws.FillRect(&sdl.Rect{int32(x), int32(y), 1, 1}, sdl.MapRGB(ws.Format, 0, uint8(-v*ech), uint8(-v*ech)))
} else {
ws.FillRect(&sdl.Rect{int32(x), int32(y), 1, 1}, sdl.MapRGB(ws.Format, uint8(+v*ech), uint8(+v*ech), 0))
}
}
}
}
e0, e1, e2 = e1, e2, e0
t += dt
// wr.Present()
w.UpdateSurface()
}
}
|
Réponse de ChatGPT 4o : Voici le résultat :
|
Test de rapidité de calcul multi-thread |
|
Bonjour, Peut-tu perfectionner le programme afin qu'il fasse tourner plusieurs processus ou thread à l'aide de plusieurs Worker, afin de tester l'efficacité dû à la présence de plusieurs cœurs dans l'ordinateur client ? Peut ajouter l'affichage d'une barre indiquant l'état d'avancement du teste ? Pouvez-vous modifier le programme afin que Juste avant de lancer le premier worker la barre de progression indique 5% Merci |
Réponse de ChatGPT / Code Generator : Voici le résultat : |