Seuls les membres ayant 30 points peuvent parler sur le chat.

Forum Casio - Actualités


Index du Forum » Actualités » Concours de rentrée 2020 - Défi Python de Quetzalcoatl !
Lephenixnoir En ligne Administrateur Points: 18530 Défis: 142 Message

Concours de rentrée 2020 - Défi Python de Quetzalcoatl !

Posté le 06/10/2020 20:17

Salut à tous ! Le concours de rentrée 2020 se poursuit avec une nouvelle épreuve pour mettre vos neurones au défi !


Si tu n'as pas encore eu l'occasion de le lire, je t'invite à regarder la présentation du concours de rentrée 2020 organisé avec TI-Planet dans l'article original du défi Python de Xuanwu, la première des trois épreuves de l'événement.

En bref, le concours se compose de trois défis de programmation Python, dans lequel tu dois optimiser la résolution d'un problème formulé par un programme à installer sur ta calculatrice graphique favorie. Le concours est ouvert à tous sans obligation d'achat et supporte 13 environnements Python (officiels et communautaires) sur les calculatrices graphiques du marché. Si tu lis ceci, tu peux certainement participer !

• Le défi de Xuanwu est un exercice de tracé à la tortue, qui est ouvert jusqu'à 18 Octobre 2020 à minuit.
• Le défi de Quetzalcoatl dont il est question ici est un exercice de tracé par coordonnées, et est ouvert jusqu'au 1er Novembre 2020 à minuit.
• Le défi du Léviathan, qui viendra en dernier, est un problème d'intelligence artificielle.

Je rappelle également que tu peux participer à tous les défis en même temps et même envoyer plusieurs solutions à chacun si tu parviens à améliorer ton score !


Le défi Python de Quetzalcoatl, le serpent à plumes

Durant le précédent défi de Xuanwu, tu as découvert une caverne fascinante sous le Larzac, non cependant sans te retrouver enfermé avec les merveilles qu'elle renferme. L'une de ces merveille est un bijou de technologie ancienne, une excavatrice qui semble avoir été utilisée pour creuser le dédale où tu es sinistré·e. Elle est en piètre état, mais tu es parvenu à la contrôler pour trouver ton chemin entre les stalactites et stalagmites qui te séparaient de ta liberté.


À ta surprise cependant, le labyrinthe souterrain semble s'enfoncer toujours plus profondément, toujours plus irrégulièrement. À plusieurs reprises, des plans de roche sous l'excavatrice cèdent en révélant des gouffres profonds. Incertain·e, tu continues de progresser, mais finis par forcer le destin et es précipité·e avec l'excavatrice dans les méandres du souterrain.

Heureusement, le véhicule a plus d'un tour dans son moteur, et se métamorphose immédiatement en ballon. Il s'agit clairement d'une machine multi-fonctions. Au même moment, les têtes de forage désormais attachées à la nacelle recommencent à fonctionner : cette nouvelle forme doit consommer moins d'énergie.

Frénétiquement, tu attrapes ta calculatrice et constates soulagé·e qu'un nouveau script de contrôle s'y est téléchargé. Te voilà maintenant avec la tâche délicate de contrôler le ballon pour traverser la caverne extrêmement accidentée. Par chance, les têtes de forage pourront percer la roche autour du ballon en cas de collision ; mais ton but est d'économiser l'énergie car tu ne sais pas combien de temps tu vas rester coincé·e.

Ce défi comporte 3 scripts Python que tu peux télécharger en bas de cet article.

polycal2.py est la bibliothèque de compatibilité graphique permettant au défi de se lancer sur les 13 environnements Python supportés par ce concours. (C'est une version légèrement modifiée du polycalc.py du défi précédent ; on laissera les curieux observer les différences !)
cave.py contient la description de la grotte et les règles du jeu. N'hésite pas à le lire si tu veux pouvoir comprendre les détails et découvrir des astuces !
cavetest.py est un exemple de solution montrant comment piloter le ballon.

Le ballon dispose de 2 contrôles. Le premier régule la quantité de gaz que tu brûles, ce qui influence ta vitesse de déplacement verticale dans la caverne. Le second permet apparemment de changer la composition du gaz, ce qui déforme le ballon. Une fois que tu entres les contrôles sur le panneau de commande, le dirigeable se conduit tout seul.

Après quelques essais précipités, tu as remarqué que chaque changement de contrôle active beaucoup de machinerie dans le ballon. Comme tu n'as aucune idée de la longueur du parcours qui t'attend ni de l'autonomie du véhicule, il est dans ton intérêt de laisser le pilote automatique le plus souvent possible.

À l'aide de ta calculatrice, définis une fonction effectuant une série d'appels à modifier_vol() pour changer les contrôles du dirigeable. Chaque appel spécifie les nouveaux contrôles et la durée de pilotage automatique. Voici un exemple qui t'amènera juste après le premier passage serré.

#cas
from cave import *

def plan():
  modifier_vol(-1, 0, 5)
  modifier_vol(1, 0, 8)
  modifier_vol(-0.89, 0.1, 6)
  modifier_vol(0, 0.1, 5)
  modifier_vol(1, 0.1, 8)

Tu peux évaluer ton plan de vol avec la fonction voler_selon, qui te montrera ton itinéraire ainsi que la consommation d'énergie engendrée sur le parcours.

from cavetest import *
voler_selon(plan)



Ton programme peut utiliser tous les outils Python de ton choix pour calculer son plan() et prendre des décisions. Tu peux notamment créer des variables, des boucles, ou des fonctions. Tu peux aussi démonter le dirigeable et inspecter le code que nous avons écrit dans cave.py si tu souhaites te former aux technologies disparues.

Attention cependant, tu n'as pas le droit de lire ou modifier des éléments de cave.py autrement que par le moyen de la fonction modifier_vol(). Tu risquerais d'endommager le ballon, et ce n'est vraiment pas le moment de faire une mauvaise chute !


Comment participer

Pour participer, envoie ta participation par mail à l'addresse info@tiplanet.org avec :

• En objet, « Défi de Quetzalcoatl »
• Ton adresse postale complète avec ton nom et prénom
• Ton adresse mail (si différente de celle utilisée pour l'envoi)
• En option, ton pseudonyme sur TI-Planet ou Planète Casio (utilisé pour la liste des participants à la fin du concours)
• Un numéro de téléphone personnel valide (utilisé uniquement en cas d'urgence, notamment en cas de problème avec une participation ou lors d'un choix de lot contraint par le temps)

Les communautés de TI-Planet et Planète Casio sont sensibles aux problématiques d'informations personnelles. Les informations que tu soumets seront utilisées uniquement pour le concours, puis supprimées lorsque l'événement sera terminé et les lots envoyés.


Lots de cette épreuve

Il y a 13 lots à remporter dans cette épreuve, fournis généreusement par les constructeurs Casio, Numworks, Texas Instruments, le revendeur Calcuso, Bernard Parisse de l'Institut Fourier (auteur de Xcas/KhiCAS), les associations CreativeCalc et UPECS gérant Planète Casio et TI-Planet, ainsi que Hewlett-Packard avec des goodies de 2019 !

Les participants ayant obtenus les 13 meilleurs scores au défi pourront choisir chacun à leur tour un lot de leur choix.

2 lots Capricorne ♑ comprenant 1 calculatrice Casio Graph 90+E, 1 pack de goodies Casio, 1 goodie Xcas, et 1 pack de goodies TI-Planet & Planète Casio

2 lots Bélier ♈ comprenant 1 solution d'émulation Casio, 1 CD de vidéos Casio fx-CG20 ou catalogue de produits Casio, 1 pack de goodies Casio, 1 goodie Xcas, et 1 pack de goodies TI-Planet & Planète Casio

Le CD contient 42 vidéos d'environ 8 heures par Jean-Michel Ferrard, originellement conçu pour la fx-CG 20 mais toujours applicable à la Graph 90+E, pour Windows et Mac.

La solution d'émulation Casio est au choix parmi :
• Une clé USB 8 Go d'émulation permanente, avec les émulateurs fx-92 Scientifique Collège+, Graph 35+E II 3.30, et Graph 90+E 3.40 à jour, pour Windows. Casio a annoncé que les mises à jour seront disponibles pour ces clefs dans le futur. Le modèle blanc est la clé Transcend 2019, le bleu est la clef EMTEC 2020.
• Une license de 3 ans permettant d'installer le fx-CP400 Manager (Windows/Mac) et le fx-CG 500 Manager (Windows/Mac). Les deux sont similaires à la ClassPad 400+E.





1 lot Serpentaire ⛎ comprenant 1 goodie HP, 1 goodie Xcas et 1 pack de goodies TI-Planète-Casio

La clé USB HP a une capacité de 16 Go, le poster mesure 59.2x40 cm.



1 lot Sagittaire ♐ comprenant 1 calculatrice NumWorks N0110, 1 pack de goodies NumWorks, 1 goodie Xcas, et 1 pack de goodies TI-Planet & Planète Casio

3 lots Balance ♎ comprenant 1 couvercle NumWorks, 1 autocollant NumWorks, 1 enveloppe ou carte postale ou carte de visite-énigme NumWorks, 1 pack de goodies NumWorks, 1 goodie Xcas et 1 pack de goodies TI-Planet & Planète Casio





1 lot Taureau ♉ comprenant 1 calculatrice TI-Nspire CX II-T CAS, 1 licence logiciel TI-Nspire CAS élève, 1 pack de goodies TI, 1 goodie Xcas, et 1 pack de goodies TI-Planète-Casio

1 lot Lion ♌ comprenant 1 calculatrice TI-Nspire CX II-T, 1 licence logiciel TI-Nspire élève, 1 pack de goodies TI, 1 goodie Xcas et 1 pack de goodies TI-Planète-Casio

1 lot Gémeaux ♊ comprenant 1 calculatrice TI-83 Premium CE Edition Python, 1 adaptateur USB, 1 clavier USB dédié, 1 pack de goodies TI et 1 pack de goodies TI-Planète-Casio

1 lot Verseau ♒ comprenant 1 calculatrice TI-83 Premium CE Edition Python avec une gravure texte laser, 1 adaptateur USB, 1 clavier USB dédié, 1 chargeur mural, 1 housse Wyngs, 1 film de protection écran Wyngs dédié, 1 extension de garantie 6 ans Calcuso, 1 pack de goodies TI et 1 pack de goodies TI-Planète-Casio

La gravure au laser de la TI-83 Premium CE Edition Python du lot Verseau est effectuée par Calcuso. Le gagnant choisissant ce lot devra nous communiquer le texte, dans la limite de 22 caractères et sans caractères spéciaux.





Tu peux trouver le détail des choix de goodies sur l'article TI-Planet annonçant le concours.



Ressources et téléchargement du programme

Scripts Python polycal2.py, cave.py et cavetest.py

Pour participer sur Graph 35+E II, il faut disposer de la mise à jour vers l'OS 3.30 qui introduit les fonctions de dessin en Python. Pour Graph 90+E, il faut de même avoir la mise à jour vers l'OS 3.40.

Mises à jour Python vers l'OS 3.30 et 3.40

Tu peux aussi utiliser un émulateur pour tester le script sur ton ordinateur ! Les émulateurs de Casio sont gratuits pendant 90 jours.

Émulateur Graph 35+E II version 3.30 pour Windows
Émulateur Graph 90+E version 3.40 pour Windows (lien direct)
Émulateur Graph 90+E version 3.40 pour Mac (lien direct)

Pour transférer les scripts Python, branche ta calculatrice avec un câble USB à l'ordinateur et appuie sur F1 (Flash USB). Ta Graph 35+E II et ta Graph 90+E se présente comme une clé USB à l'ordinateur. Tu peux alors coller les fichiers dans le dossier principal puis éjecter la pseudo-clé USB. Ensuite, lance les scripts depuis l'application Python !

Pour les autres modèles, vois dans l'article TI-Planet. Tu peux participer avec toutes les combinaisons calculatrice/Python suivantes !

• TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
• Casio Graph 35+E II
• Casio Graph 90+E / fx-CG50
• HP Prime en mode CAS
• HP Prime avec appli Python intégrée (firmware instable, déconseillé)
• NumWorks (y compris Delta et Omega)
• NumWorks avec l'appli KhiCAS en mode Micropython (Delta uniquement)
• NumWorks avec l'appli KhiCAS en mode de compatibilité Python (Delta uniquement)
• TI-Nspire CX II
• TI-Nspire avec Ndless et Micropython
• TI-Nspire CX/CM avec Ndless et Micropython
• TI-Nspire CX avec Ndless et KhiCAS CX

Ce défi mettra tes capacités de pilote à l'épreuve ! Sors dès que tu peux ta calculatrice pour attaquer la caverne et voler jusqu'à la sortie du défi de Quetzalcoatl !

Une autre annonce sera faite pour le troisième défi, et d'autres encore pour les résultats lorsque les défis seront terminés. Stay tuned et à bientôt sur Planète Casio !

Article connexe sur TI-Planet : Concours de rentrée 2020 - défi Python de Quetzalcóatl


Critor En ligne Administrateur Points: 1921 Défis: 18 Message

Citer : Posté le 07/10/2020 13:26 | #


Merci.

Petit changement pour ce défi-ci, vous avez droit aux captures d'écran de ceux qui ont participé avant vous :
https://tiplanet.org/concours_rentree2020.php?delta=0&infos=1&worse=1&invalid=1
Supersolga Hors ligne Membre Points: 96 Défis: 0 Message

Citer : Posté le 07/10/2020 14:19 | #


Comment on fait pour participer avec une Graph 85 ?
Donnez-moi un point fixe et un levier et je soulèverai la Terre
-Archimède
Critor En ligne Administrateur Points: 1921 Défis: 18 Message

Citer : Posté le 07/10/2020 14:28 | #


Pas possible désolé, il n'y a pas de solution Python graphique pour Graph 85.

Il te faut prendre un émulateur, Graph 35+E II 3.30 par exemple :
https://www.planet-casio.com/Fr/logiciels/voir_un_logiciel_casio.php?showid=124

Ou encore mieux avec la couleur, Graph 90+E 3.40 :
https://tiplanet.org/forum/archives_voir.php?id=2618874
Tituya Hors ligne Rédacteur Points: 1156 Défis: 16 Message

Citer : Posté le 07/10/2020 17:16 | #


Salut !
Comme pour le premier concours, hop je vous fournis un script pygame permettant d'émuler sur ordi le code

#cas
from math import pi, sin, cos, sqrt
from polycal2 import *
import pygame
from pygame.locals import *

def rnd():
  global s
  rnd_max = 0x7fff
  s = (s * 214013 + 2531011) % 4294967296
  return ((s // (2*rnd_max + 1)) & rnd_max) / rnd_max

def hmap(t):
  frq, pha, hm, amp = [ 1, 3, 15, 21, 39, 51, 97, 145 ], [], [], []
  for i in range(8):
    amp.append((rnd() + 1) * (cave_h * 27) / 200 / 1.2**i)
  for k in frq:
    pha.append(pi * rnd())
  for x in range(cave_w):
    hm.append(int(sum([amp[i] * (1 + sin(fix_angle(frq[i]*x/cave_w + pha[i]))) / 2 for i in range(len(amp))])))
  return [ h - min(hm) + t for h in hm ]

cave_w, cave_h, s = 128, 64, 0xdeadbeef
fl, cv = hmap(2), hmap(8)

ratio = 3
screen_w = 384*ratio
screen_h = 192*ratio

zx, zy = (screen_w - 1) / (cave_w - 1), (screen_h - 1) / (cave_h - 1)

pygame.init()
pygame.mixer.quit()
pygame.display.set_caption('Concours')
fenetre = pygame.display.set_mode((screen_w,screen_h))

def draw_line(x1, y1, x2, y2, c):
    pygame.draw.line(fenetre, (c),(x1, y1), (x2, y2))

def fill_rect(x, y, w, h, c):
    pygame.draw.rect(fenetre, c, Rect(x, y, 3, 15*ratio))

def interpol1(yi, yf, dx):
  return yi + dx*(yf - yi)

def fill_ellipse(x, y, rx, ry, c):
  for h in range(-int(ry), int(ry+1)):
    w = sqrt(max(0, rx*rx*(1-h*h/ry/ry)))
    x1, x2 = x - w, x + w
    yc = y + h
    draw_line(x1, yc, x2, yc, c)

def interpol_list(lst, i):
  i0 = int(i)
  v = lst[i0]
  if i > i0 and i < len(lst) - 1:
    v = interpol1(v, lst[i0 + 1], i - i0)
  return v

def test_collision(x, y):
  f = cave_h - interpol_list(fl, x)
  return y >= f or y <= f-interpol_list(cv, x)

def test_collision_rect(x, y, dx, dy):
  x1, x2, y1, y2 = max(0, x - dx), min(cave_w - 1, x + dx), y - dy, y + dy
  return test_collision(x1, y1) + test_collision(x2, y1) + test_collision(x1, y2) + test_collision(x2, y2)

def test_balloon(x, y, rx, ry, d_vert):
  rmax, r2, k, collisions = [rx, ry][d_vert], [ry, rx][d_vert], -1, 0
  while k < rmax:
    k = min(k + 1, rmax)
    k2 = sqrt(max(0, r2*r2*(1 - k*k/rmax/rmax)))
    collisions += test_collision_rect(x, y, [k, k2][d_vert], [k2, k][d_vert])
  return collisions

def rxy(a):
  if a%2 == 1:
    rx, ry = 0, 1-2*(a%4 == 3)
  else:
    a = fix_angle(a * pi/2)
    rx, ry = abs(cos(a)), abs(sin(a))
  return 1 + abs(rx), 1 + abs(ry)

colors = ([0, 0, 0], [255, 255, 255], [0, 0, 255], [255, 0, 0], [159, 159, 159])

def modifier_vol(ay, da, dt):
  global state
  if ay or da:
    state[4] += 10
  x, y, a = state[0:3]
  while state[0] < cave_w - 1 and dt:
    state[0] += 1
    state[2] = max(0, min(1, a + da))
    state[3] -= ay
    state[1] = max(0, min(cave_h - 1, state[1] + state[3]))
    dt = max(0, dt - 1)  
    da, dapi, dx = abs(state[2] - a), abs(state[2] - .5), 1
    state[4] += 3*(da > 0)*(1 + da) + 2*(dapi > 0)*(1 + dapi)
    xc, yc, dx = x, y, 1
    rx, ry = rxy(state[2])
    if state[1] != y:
      dx = min(1 / abs(state[1] - y), 1)
    collisions = test_balloon(state[0], state[1], rx, ry, 0) + test_balloon(state[0], state[1], rx, ry, 1)
    if collisions:
      state[4] += 7 * (1 + collisions)
    while xc < state[0]:
      xc += dx/zx
      yc = interpol1(y, state[1], xc - x)
      rx, ry = rxy(interpol1(a, state[2], state[2] - a))
      fill_ellipse(xc * zx, yc * zy, rx * zx, ry * zy, colors[2 + (collisions > 0)])
    x, y, a = state[0], state[1], state[2]

def voler_selon(f, affiche = True):
  global state, fl, cv
  state = [0, 12, .5, 0,0]
  fill_rect(0, 0, screen_w, screen_h, colors[4])
  for x in range(cave_w):
    f1, dx = cave_h - fl[x], 0
    c1 = f1 - cv[x]
    while dx < zx:
      f2 = cave_h - interpol_list(fl, x + dx/zx)
      c2 = f2 - interpol_list(cv, x + dx/zx)
      draw_line(x*zx + dx, c2 * zy, x*zx + dx, f2 * zy, colors[1])
      dx += 1
      draw_line(x * zx, c1 * zy, (x + 1) * zx, c2 * zy, colors[0])
      draw_line(x * zx, f1 * zy, (x + 1) * zx, f2 * zy, colors[0])
  f()
  if state[0] < cave_w - 1:
    modifier_vol(0, 0, cave_w - 1 - state[0])
  boucle=False
  while not boucle and affiche:
    for event in pygame.event.get():
      if event.type==QUIT:
       boucle=True
    pygame.display.update()
  print(state)
  print('Consommation : ' + str(state[4]))
  print('GG')
  return state[4]


Ce script est jeune, je sais pas encore si il fournit des bugs, ça m'étonnerai car je change rien mais dans le doute testez sur calto après.
Bretagne > Reste du globe
(Et de toute façon, vous pouvez pas dire l'inverse grâce à Bzh)



Critor En ligne Administrateur Points: 1921 Défis: 18 Message

Citer : Posté le 07/10/2020 18:11 | #


Merci beaucoup @Tituya.
Captainluigi Hors ligne Membre Points: 782 Défis: 1 Message

Citer : Posté le 08/10/2020 11:47 | #


Et ça s'utilise comment, Tituya ?
(A chaque fois ça ne marche pas, polycal2 manquant)
Les bons artistes copient, les grands artistes volent. Picasso
Jouez à Mario sans arrêt sur votre Casio !
Cliquez pour découvrir
Cliquez pour recouvrir
Kikoodx Hors ligne Membre Points: 2195 Défis: 11 Message

Citer : Posté le 08/10/2020 12:07 | #


Télécharge les scripts du concours : https://tiplanet.org/forum/archives_voir.php?id=2646544
Remplace le contenu de cave.py par le script de Tituya.
2+2=5
Perdu
Captainluigi Hors ligne Membre Points: 782 Défis: 1 Message

Citer : Posté le 08/10/2020 12:11 | #


Kikoodx a écrit :
Télécharge les scripts du concours : https://tiplanet.org/forum/archives_voir.php?id=2646544
Remplace le contenu de cave.py par le script de Tituya.

Okay
Les bons artistes copient, les grands artistes volent. Picasso
Jouez à Mario sans arrêt sur votre Casio !
Cliquez pour découvrir
Cliquez pour recouvrir

LienAjouter une imageAjouter une vidéoAjouter un lien vers un profilAjouter du codeCiterAjouter un spoiler(texte affichable/masquable par un clic)Ajouter une barre de progressionItaliqueGrasSoulignéAfficher du texte barréCentréJustifiéPlus petitPlus grandPlus de smileys !
Cliquez pour épingler Cliquez pour détacher Cliquez pour fermer
Alignement de l'image: Redimensionnement de l'image (en pixel):
Afficher la liste des membres
Pour coloriser votre code, cliquez ici.
Sinon cliquez sur le bouton ci-dessous.
:bow: :cool: :good: :love: ^^
:omg: :fusil: :aie: :argh: :mdr:
:boulet2: :thx: :champ: :whistle: :bounce:
valider
 :)  ;)  :D  :p
 :lol:  8)  :(  :@
 0_0  :oops:  :grr:  :E
 :O  :sry:  :mmm:  :waza:
 :'(  :here:  ^^  >:)

Σ π θ ± α β γ δ Δ σ λ
Veuillez donner la réponse en chiffre
Vous devez activer le Javascript dans votre navigateur pour pouvoir valider ce formulaire.

Si vous n'avez pas volontairement désactivé cette fonctionnalité de votre navigateur, il s'agit probablement d'un bug : contactez l'équipe de Planète Casio.

Planète Casio v42 © créé par Neuronix et Muelsaco 2004 - 2020 | Il y a 84 connectés | Nous contacter | Qui sommes-nous ? | Licences et remerciements

Planète Casio est un site communautaire non affilié à Casio. Toute reproduction de Planète Casio, même partielle, est interdite.
Les programmes et autres publications présentes sur Planète Casio restent la propriété de leurs auteurs et peuvent être soumis à des licences ou copyrights.
CASIO est une marque déposée par CASIO Computer Co., Ltd