π
<-
Chat plein-écran
[^]

Résultats finale en équipe concours IA 1000 Bornes Python

Résultats finale en équipe concours IA 1000 Bornes Python

Unread postby critor » 22 Jun 2024, 22:38


Voici enfin venu aujourd'hui le jour des résultats de la finale en équipe de notre concours d'intelligence artificielle Python 1000 Bornes.

Nos remerciements une fois encore tous ceux qui ont rendu possible cet événement auquel nous pensions déjà depuis plusieurs années et qui nous tenait tant à cœur :



Sommaire :




1) Les équipes invitées

Go to top

Les candidats avaient cette année la possibilité de participer en équipe, et les 2 meilleures équipes ont été conviés pour cette finale dédiée :
  • nsi42 avec 14 membres : c'est l'équipe de Vincent Robert alias cent20 chez nous, enseignant en Mathématiques et NSI au Lycée Louis Pasteur à Avignon, et de ses disciples
  • br.AI.n all.IA.ge avec 6 membres, regroupant notamment SlyVTT, TIny_Hacker, Afyu ainsi que plusieurs élèves de ce dernier



2) La finale en équipe

Go to top

La finale en équipe prend la forme d'un quadruel, avec 2 IAs pour chaque équipe.

Chaque équipe avait le choix entre nous fournir 2 IAs différentes, ou bien 1 seule IA à faire jouer 2 fois.

C'était l'occasion de donner une toute nouvelle dimension à ce concours, en plus des IA adverses il fallait ici tenir compte de l'IA alliée et tenter de ne pas la pénaliser.

Les IAs gérant et optimisées pour ce format devaient nous être communiquées jusqu'au dimanche 19 mai 2024 23h59 GMT+2.



3) Les IAs des équipes

Go to top

Afyu et SlyVTT nous ont bien fourni 2 IAs pour le compte de leur équipe br.AI.n all.IA.ge :

cent20 a malheureusement eu une année assez éprouvante et n'a pas été disponible pour encadrer son équipe nsi42 ce troisième trimestre ; nous n'avons rien reçu.
Il nous a toutefois dit de reprendre sans modification l'IA du meilleur membre de son équipe au classement individuel, Camille A. qui avait décroché la 10e place.
Il s'agit donc de l'IA ia_ca_07



4) Modalités d'évaluation

Go to top

Nous avons fait s'affronter ces équipes lors d'une grande série de quadruels, très exactement 88'888 quadruels.

Chaque quadruel implique 4 joueurs :
  • les 2 IAs alliées de br.AI.n all.IA.ge
  • et l'IA de Camille A. instanciée 2 fois

Rappelons le 1000 Bornes est un jeu se jouant à tour de rôle. Pour 4 joueurs, pourront alors jouer dans l'ordre : joueur1, joueur2, joueur3, joueur4, joueur1, joueur2, joueur3, joueur4, joueur1, …

Pour n'avantager et de désavantager personne, nous changeons l'ordre des joueurs à chaque nouveau quadruel.
Seule et unique contrainte d'ordre que nous avions donnée : les IA alliées occuperont des positions de même parité (afin de pouvoir s'identifier, aucun canal de communication n'ayant été prévu dans le code encadrant les quadruels).



5) Résultats

Go to top

Intéressons nous maintenant au classement des IAs, en terme de scores, pour chaque quadruel.

Voici toutes les fois où chaque IA est première d'un quadruel (meilleur des 4 scores) en fonction des différentes positions :



Joueur 1
Joueur 2
Joueur 3
Joueur 4
TOTAL
SlyVTT
6'310
(42,59%)
7'194
(48,56%)
9'540
(32,20%)
8'378
(28,28%)
31'422
(35,35%)
Afyu
20'223
(68,25%)
21'375
(72,14%)
8'585
(57,95%)
7'703
(52,00%)
57'886
(65,12%)
Camille A.
0
(0,00%)
0
(0,00%)
0
(0,00%)
0
(0,00%)
0
(0,00%)

Camille A. a le mérite de nous avoir codé dès le départ pour des duels une IA compatible avec le format quadruel de la finale. Son IA ne déclenche en effet aucune erreur dans ce format alors non anticipé, c'est remarquable !
Malheureusement, comme son IA n'a pas été mise à jour elle est tout sauf optimale dans ce nouveau contexte et ne gagne pas une seule fois.
Le mieux qu'elle arrive à faire, 3 fois sur les 88888 quadruels, c'est d'être deuxième ex æquo avec SlyVTT.

Sans besoin d'autres calculs hélas, nous proclamons donc la victoire de l'équipe br.AI.n all.IA.ge contre nsi42.

Les chefs des 2 équipes vont donc maintenant pouvoir choisir, par ordre de classement, parmi les très gros lots destinés à récompenser fort généreusement leurs membres.
Si ils le souhaitent, ils pourront nous indiquer à quels membres de leurs équipes expédier directement les divers éléments de chaque lot.
Image
User avatar
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Level up: 45%
 
Posts: 41677
Images: 15208
Joined: 25 Oct 2008, 00:00
Location: Montpellier
Gender: Male
Calculator(s):
MyCalcs profile
YouTube: critor3000
Twitter: critor2000
GitHub: critor

Re: Résultats finale en équipe concours IA 1000 Bornes Pytho

Unread postby SlyVTT » 23 Jun 2024, 09:53

Merci pour la publications des résultats Critor.

L'équipe br.AI.n all.IA.ge est très contente de cette victoire.
Nous tenons à remercier l'équipe nsi42 pour avoir participé au challenge par équipe, nous savons en effet que cette année a été très difficile pour Cent20.
Merci à Camille pour avoir permis à l'équipe de participer et de hisser les couleurs de l'équipe nsi42.

Je laisserai Afyu compléter les éléments qui suivent, mais globalement nos 2 IAs d'équipe sont très très fortement basées sur nos IAs individuelles fournies dans le cadre de la finale individuelles.

Pour ma part, il s'agit purement et simplement de la même IA à laquelle j'ai rajouté une conditions sur le déclenchement de l'attaque.

Je vérifie juste que la liste des adversaires ne contient personne dont le nom du groupe " br.AI.n all.IA.ge " via cette petite portion de code :

Code: Select all
        # PHASE 1 : on recherche qui est le plus près de la victoire et on en fait la cible privilégiée

        tuples = []
        nb_total_cibles = 0

        for i in range(self.nbr_joueurs):
            # on balaye l'ensemble des joueurs mais on évite de se cibler
            # pour multiplayer, on évite d'attaquer un partenaire de sa propre équipe en regardant si il fait partie du
            # meme groupe

            # TODO : activer cette condition quand les groupes seront activés
            if not i == self.num_joueur and not self.nom_groupe == self.infos_joueurs[i].nom_groupe:
            # if not i == self.num_joueur:
                tuples.append((self.infos_joueurs[i].bornes, i))
                nb_total_cibles += 1
            else:
                print_red("Je vais pas me tirer une balle dans le pied quand même (ou dans le pied de mon équipe) !!!")

        tuples.sort(key=lambda x: x[0], reverse=True)
        print(tuples)
        if len(tuples)==0:
            return None
        best_target = tuples[0][1]
        kms_target = tuples[0][0]
        print_cyan("Voici mon inventaire de la situation" + str(tuples))
        print_cyan(
            "MEILLEURE CIBLE : Joueur #" + str(best_target) + " avec ses " + str(kms_target) + " Km au compteur !!!")


Cela me permet de m'assurer que je n'attaque pas quelqu'un de mon équipe. Dans l'absolu cela fonctionne quel que soit le nombre de joueur.
Pour l'anecdote, mon bug de numérotation est encore présent, donc dans un certain nombre de cas je n'attaque pas les joueurs 3 et 4 ;)

Encore une fois, merci à tous pour ce super concours.
Merci aussi à Cent20 pour avoir malgré tout réussi à consolider une équipe. On espère que l'année prochaine tu auras plus de temps afin de participer à la hauteur de ta maîtrise.
Et bravo encore à Camille pour son score individuel ainsi que pour avoir permis aux nsi42 de participer.
Some works in progress :
The GUI Toolkit NF for nSpireMyShmup for fxCG-50Magic Light for Casio Graph 90+E
and
Magic Light for nSpire CX/CX-II
Simple Text Editor for nSpireOutRun for Casio Graph 90+E
95%
50%
100%
75%
100%
And more to come ... stay tuned
User avatar
SlyVTTPremium
Niveau 12: CP (Calculatrice sur Pattes)
Niveau 12: CP (Calculatrice sur Pattes)
Level up: 45.1%
 
Posts: 515
Images: 31
Joined: 19 Jan 2021, 09:41
Location: France
Gender: Male
Calculator(s):
MyCalcs profile
GitHub: SlyVTT

Online

Re: Résultats finale en équipe concours IA 1000 Bornes Pytho

Unread postby Afyu » 23 Jun 2024, 19:32

Bravo Camille et l'équipe nsi42 !! :clap:
Vous terminez sur le podium. :)

Oui, ce fut une année bien chargée et parfois chargée avec des ennuis divers et variés, plus ou moins graves et plus ou moins longs à gérer... En particulier, je souhaite à cent20 un rétablissement total et le plus rapidement possible. :favorite:

Pour la finale par équipe, j'ai modifié mon IA pour qu'elle n'attaque pas une autre IA de mon équipe. Tout comme l'IA de SlyVTT, le nombre de participants importe peu et mon IA ne se contente pas d'attaquer le participant de rang d'appel immédiatement avant ou après. ;)

La modification est dans les premières lignes, lorsqu'il s'agît de faire la liste des numéros de tous les adversaires.

Le code suivant dresse la liste des adversaires pour le mode "finale individuelle" :
Code: Select all
    liste_bornes=[self.infos_joueurs[i].bornes+i for i in range(self.nbr_joueurs)]
    liste_bornes[self.infos_joueur.num_joueur]=-1
    liste_bornes_adversaires=[liste_bornes[i]-i for i in range(self.nbr_joueurs) if i != self.infos_joueur.num_joueur]
    adversaires_ordre_decroissant_bornes=[liste_bornes.index(j) for j in sorted(liste_bornes)[::-1]][:-1]


Le code suivant dresse la liste des adversaires pour le mode "finale par équipe" :
Code: Select all
    liste_bornes=[self.infos_joueurs[i].bornes+i for i in range(self.nbr_joueurs)]
    liste_bornes[self.infos_joueur.num_joueur]=-1
    liste_bornes_adversaires=[liste_bornes[i]-i for i in range(self.nbr_joueurs) if i != self.infos_joueur.num_joueur]
    adversaires_ordre_decroissant_bornes=[liste_bornes.index(j) for j in sorted(liste_bornes)[::-1] if self.infos_joueurs[liste_bornes.index(j)].nom_groupe != "br.AI.n all.IA.ge"]


La seule différence est que l'on vérifie si le participant n'appartient pas à l'équipe "br.AI.n all.IA.ge".

L'astuce du +i suivi du -i permet d'éviter d'oublier un participant dans le cas d'une égalité de nombre de bornes posées. :bj:
En effet, avec ce +i avec i qui correspond au numéro (d'appel) du participant, qui est ensuite compensé par un -i, j'ajoute temporairement et artificiellement i bornes au total de bornes du participant numéro i et ainsi de suite pour chaque participant et je suis alors sûr de ne pas trouver 2 participants avec le même nombre de bornes posées, tant qu'il y a moins de 25 participants appelés (ce qui laisse un peu de marge !). :D

Cette IA proposée pour la finale en équipe est identique en tous points à celle proposée pour la finale individuelle, à part le nom de l'IA, le numéro de version de l'IA et l'instruction de construction de la liste des adversaires, comme citée quelques lignes au-dessus.

Mais nous avons tout de même vérifié qu'il n'y avait pas de "raté" dans la désignation de l'adversaire à attaquer. Pour ça, nous avons modifié le script kbliprv.py en ajoutant quelques lignes, qui comptent le nombre d'attaque vers un membre de la même équipe et qui affichent le bilan une fois la partie terminée. Le script kblibprv.py modifié est présenté ci-dessous, les lignes ajoutées étant suffixées d'un ###modif### pour pouvoir les identifier plus facilement :)
Code: Select all
# les scripts d'IA ne doivent en aucun cas acceder au contenu de ce script

from kblibpub import *
from random import choice, randint, seed


#-----------------
# classe jeujoueur
#-----------------
class c_jeujoueur(c_infos_jeu_et_main):
  def nouvelle_manche(self, nbr_cartes, taille_main, bornes_arrivee):
    self.main_affichable = [None] * taille_main
    super().nouvelle_manche(nbr_cartes, taille_main, bornes_arrivee)

  def main_append(self, carte):
    for k in range(TAILLE_MAIN):
      if self.main_affichable[k] == None:
        self.main_affichable[k] = carte
        return k

  def main_remove(self, carte):
    for pos in range(TAILLE_MAIN):
      if self.main_affichable[pos] == carte:
        self.main_affichable[pos] = None
        return pos

  def traite_coup(self, coup, redraw=0, posaff=-1):
    points_old = self.points
    cf = len(self.coups_fourres_autorises) and coup.destination == self.num_joueur and coup.origine != SABOT \
      and coup.carte in self.coups_fourres_autorises
    super().traite_coup(coup)
    if coup.origine == SABOT and coup.destination == self.num_joueur:
      pos = self.main_append(coup.carte)
    elif coup.origine == self.num_joueur:
      pos = self.main_remove(coup.carte)
      if posaff >= 0 and pos != posaff and self.main_affichable[posaff] == coup.carte:
        self.main_affichable[posaff], self.main_affichable[pos] = self.main_affichable[pos], self.main_affichable[posaff]
        pos = posaff
      #if redraw and self.num_joueur == show_main_joueur: redraw_main(None, pos, self.num_joueur)
    #if coup.destination == SABOT: draw_carte_defausse(coup.carte)
    #if coup.destination == self.num_joueur and coup.origine != SABOT:


#-------------------------
# fonctions pour la pioche
#-------------------------
def melange_liste(lst):
  n = len(lst)
  for i in range(n - 1):
    j = randint(i, n - 1)
    lst[i], lst[j] = lst[j], lst[i]

def permute_liste(lst, d):
  n = len(lst)
  for istart in range(0, n, d):
    iend = min(istart + d, n)
    lst[istart:iend] = [lst[iend - 1]] + lst[istart:iend - 1]

#----------------------
# fonctions pour les IA
#----------------------
def traite_coup_all(coup, num_joueur, joueurs, infos_joueurs, pos = -1):
  for i in range(nbr_joueurs):
    # censure de la carte tiree pour les autres IAs
    tcoup = coup.origine == SABOT and coup.destination != i and c_coup(coup.origine, None, coup.destination) or coup
    joueurs[i].traite_coup(tcoup)
    infos_joueurs[i].traite_coup(tcoup, 1, pos)

#--------------------
# fonction principale
#--------------------
def kb_partie(classes_joueurs, show_help=0):
  #global col_w, y1, n_cartes_lgn, n_cartes_col, carte_w, carte_h, cartebox_w, cartebox_h, i_display_mode, ysep, xsep
  #global joueurs_col, show_main_joueur, pioche_len
  global main_xm, jeu_xm, pioche_xm, TAILLE_MAIN, nbr_joueurs
  TAILLE_MAIN = 7
  POINTS_OBJECTIF = 9000*100
  sep1, sep2 = "=" * 21, "-" * 20
  #if show_help:
  #  draw_help()
  nbr_joueurs = len(classes_joueurs)
  show_main_joueur = 0


  joueurs = []
  for num_joueur in range(nbr_joueurs):
    c_joueur = classes_joueurs[num_joueur]
    joueurs.append(c_joueur(num_joueur, nbr_joueurs, POINTS_OBJECTIF))

  infos_joueurs = [c_jeujoueur(num_joueur, nbr_joueurs, POINTS_OBJECTIF, 1) for num_joueur in range(nbr_joueurs)]
  fin_de_partie = 0
  i_manche = 0

  for joueur in joueurs:
    if joueur.nom_groupe:
      for obj in joueurs + infos_joueurs:
        obj.rejoint_groupe(joueur.num_joueur, joueur.nom_groupe)

  print(sep1)
  print("Debut de partie a {:d}pts".format(POINTS_OBJECTIF))
  print(sep2)
  for joueur in joueurs: print(joueur.id_str())
  print(sep1)
  ATTAQUES=dict() ###modif###
  for i in range(nbr_joueurs): ###modif###
    for j in range(nbr_joueurs): ###modif###
      ATTAQUES[(i,j)]=0 ###modif###

  pioche_r = [I_CAMION_CITERNE, I_VEHICULE_INCREVABLE, I_AS_VOLANT, I_VEHICULE_PRIORITAIRE]
  pioche_r += [I_PANNE_ESSENCE, I_CREVAISON, I_ACCIDENT]*3 + [I_LIMITATION,]*4 + [I_FEU_ROUGE,]*5
  pioche_r += [I_POMPE_ESSENCE, I_ROUE_SECOURS, I_REPARATIONS, I_FIN_LIMITATION]*6 + [I_FEU_VERT,]*14
  pioche_r += [I_25_BORNES, I_50_BORNES, I_75_BORNES]*10 + [I_100_BORNES,]*12 + [I_200_BORNES,]*4

  while not fin_de_partie: # nouvelle partie
    i_manche += 1
    bornes_arrivee_allonge = 1000
    bornes_arrivee = nbr_joueurs <= 3 and 700 or bornes_arrivee_allonge
    allonge_demandee = 0
    melange_liste(pioche_r)

    for i_pioche in range(nbr_joueurs):
      if fin_de_partie: break

      print("Manche {:d} Pioche {:d}".format(i_manche, i_pioche + 1))
      print(sep2)

      permute_liste(pioche_r, nbr_joueurs)
      pioche = list(pioche_r)
      pioche_len = len(pioche)

      for obj in joueurs + infos_joueurs: obj.nouvelle_manche(pioche_len, TAILLE_MAIN, bornes_arrivee)

      #show(infos_joueurs)
      #clear_main(show_main_joueur)

      for k in range(TAILLE_MAIN - 1):
        for num_joueur in range(nbr_joueurs):
          carte = pioche.pop()
          pioche_len -= 1
          coup = c_coup(SABOT, carte, num_joueur)
          traite_coup_all(coup, num_joueur, joueurs, infos_joueurs)

      fin_de_manche = 0
      while pioche_len and not fin_de_manche and not fin_de_partie: # nouvelle manche

        for num_joueur in range(nbr_joueurs):
          if fin_de_manche or fin_de_partie: break
          joueur = joueurs[num_joueur]
          infos_joueur = infos_joueurs[num_joueur]
          joueur_dest = None
          infos_joueur_dest = None

          tour_termine = 0
          tour_commence = 0

          while not tour_termine and (pioche_len or len(infos_joueur.main) >= TAILLE_MAIN):
            useposmain = 0
            if tour_commence and len(infos_joueur.main) < TAILLE_MAIN:
              coup = c_coup(SABOT, None, num_joueur)
            else:
              coup = joueur.decide_coup()
              if coup == None:
                if num_joueur != show_main_joueur:
                  show_main_joueur = num_joueur
                  #draw_main(infos_joueur.main_affichable, num_joueur)
                #PC_wnokey()
                #coup = choix_clavier_carte(infos_joueur.main_affichable, num_joueur, infos_joueurs)
                useposmain = 1
                if coup == None:
                  fin_de_partie = 1
                  break

              tour_commence = 1

            coup_invalide = coup.invalide(nbr_joueurs)

            if not coup_invalide:
              if coup.destination != SABOT:
                joueur_dest = joueurs[coup.destination]
                #ATTAQUES[(joueur.num_joueur,joueur_dest.num_joueur)]+=1
                infos_joueur_dest = infos_joueurs[coup.destination]
              coup_invalide = infos_joueur.coup_invalide(coup)

            if not coup_invalide and joueur_dest:
              coup_invalide = infos_joueur_dest.coup_invalide(coup)
              if not coup_invalide and est_carte_attaque(coup.carte) and coup.origine != SABOT and coup.destination != SABOT: ###modif###
                ATTAQUES[(joueur.num_joueur,joueur_dest.num_joueur)]+=1 ###modif###

            if coup_invalide:
              print("Coup invalide : ", coup.to_str())
              print(infos_joueur.to_str())
              if coup.destination >= 0 and coup.destination != num_joueur:
                print(infos_joueurs[coup.destination].to_str())
              coup.destination = SABOT
              coup.origine = num_joueur
              if coup.carte == None or not coup.carte in infos_joueur.main:
                coup.carte = choice(infos_joueur.main)
            else:
              if coup.origine == SABOT:
                coup.carte = pioche.pop()
                pioche_len -= 1

            if coup.destination != SABOT:
              joueur_dest = joueurs[coup.destination]
              infos_joueur_dest = infos_joueurs[coup.destination]

            if coup.destination != SABOT and est_carte_botte(coup.carte):
              back_vitesse = list(infos_joueur.pile_vitesse)
              back_bataille = list(infos_joueur.pile_bataille)
            # information toutes IA du dernier coup
            traite_coup_all(coup, num_joueur, joueurs, infos_joueurs, not useposmain and -1 or pos_choix)

            if coup.destination != SABOT and est_carte_botte(coup.carte):
              if len(infos_joueur.pile_vitesse) < len(back_vitesse):
                infos_joueur.traite_coup(c_coup(None, back_vitesse[-1], SABOT))
              if len(infos_joueur.pile_bataille) < len(back_bataille):
                infos_joueur.traite_coup(c_coup(None, back_bataille[-1], SABOT))

            if not allonge_demandee and bornes_arrivee < bornes_arrivee_allonge and joueur_dest \
              and infos_joueur_dest.bornes == bornes_arrivee:
              allonge_demandee = 1
              pari_allonge = joueur_dest.pari_allonge(bornes_arrivee_allonge)

              if pari_allonge == None:
                if num_joueur != show_main_joueur:
                  show_main_joueur = num_joueur
                  #draw_main(infos_joueur.main_affichable, num_joueur)
                #PC_wnokey()
                pari_allonge = choix_allonge(num_joueur, infos_joueur)
                if pari_allonge == None: fin_de_partie = 1
              if pari_allonge:
                bornes_arrivee = bornes_arrivee_allonge
                print(infos_joueur.id_str() + " allonge {:04d}km".format(bornes_arrivee))
                for obj in joueurs + infos_joueurs: obj.allonge(joueur_dest, bornes_arrivee)
              else: break

            fin_de_manche = infos_joueur.victoire_manche()
            tour_termine = coup.origine != SABOT and not est_carte_botte(coup.carte)

          for infos_joueur2 in infos_joueurs:
            if infos_joueur2.victoire_manche():
              fin_de_manche = 1
              break

      #print(sep2)
      #for infos_joueur in infos_joueurs:
        #print(infos_joueur.id_str() + " {:04d}km".format(infos_joueur.bornes) +
          #(infos_joueur.victoire_manche() and " Victoire" or ""))
      #print(sep2)
      for obj in joueurs + infos_joueurs: obj.fin_manche([infos_joueurs[i].bornes for i in range(nbr_joueurs)], pioche_len)
      #print(sep2)

      score_gagnant, n_gagnants = 0, 0
      for infos_joueur in infos_joueurs:
        t = infos_joueur.victoire_tournoi()
        if t and i_pioche + 1 == nbr_joueurs: fin_de_partie = 1
        if infos_joueur.points > score_gagnant:
          score_gagnant = infos_joueur.points
          n_gagnants = 1
        elif infos_joueur.points == score_gagnant: n_gagnants += 1
        print(joueurs[infos_joueur.num_joueur].id_str() + " {:05d}pt".format(infos_joueur.points) +
          " s"[infos_joueur.points > 1] + (t and " It's over {:d}".format(POINTS_OBJECTIF) or ""))
        #print(infos_joueur.id_str() + " {:05d}pt".format(infos_joueur.points) +
        #  " s"[infos_joueur.points > 1] + (t and " It's over {:d}".format(POINTS_OBJECTIF) or ""))
      print(sep1)
  exaequo = n_gagnants > 1
  print("Fin de partie")
  for cle in ATTAQUES.keys(): ###modif###
    if (cle[0]-cle[1])**2==4: ###modif###
      print(cle,ATTAQUES[cle]) ###modif###
  #print("ATTAQUES :",ATTAQUES)

#  for joueur in joueurs: print(joueur.id_str())
#  print(sep1)

  for k in range(nbr_joueurs):
    infos_joueur = infos_joueurs[k]
    if infos_joueur.points == score_gagnant:
      print(exaequo and "Ex aequo" or "Gagnant", joueurs[k].id_str())
      #print(exaequo and "Ex aequo" or "Gagnant", infos_joueur.id_str() + joueurs[k].id_str())
      if not exaequo: print('Le mot du gagnant:\n"' + joueurs[k].msg_joueur + '"')

Je remercie grandement l'équipe organisatrice de ce formidable concours qui rivalise d'inventivité et d'audace, ainsi que tous les participants sans qui ce concours aurait été bien moins amusant et stimulant, et pour finir toutes celles et ceux qui ont permis d'avoir un concours si bien doté en lots !! :favorite:
User avatar
AfyuVIP++
Niveau 15: CC (Chevalier des Calculatrices)
Niveau 15: CC (Chevalier des Calculatrices)
Level up: 97.1%
 
Posts: 396
Images: 52
Joined: 30 Oct 2019, 19:17
Gender: Male
Calculator(s):
MyCalcs profile
Class: plutôt, oui :)

Online

Re: Résultats finale en équipe concours IA 1000 Bornes Pytho

Unread postby Afyu » 23 Jun 2024, 20:45

J'en profite pour glisser un petit mot pour présenter ce que j'ai mis en place pour aider mes élèves (qui ne sont pas en spé NSI et pas expert en informatique non plus) afin qu'ils puissent participer sans avoir à installer quoi que ce soit et sans même avoir besoin d'ordinateur puisque tout peut se faire depuis un téléphone (même si c'est assez peu confortable pour saisir des lignes de code, on est d'accord !).

J'ai créé ce repl sur replit.com qui contient les scripts du concours, un peu comme la version Upsilon disponible ici mais avec quelques petites différences : j'ai retiré toute la partie graphique et le script kb.py renommé en main.py lance directement une partie avec l'IA contenue dans ia_perso.py contre l'IA contenue dans ia_random.py sans aucune saisie supplémentaire, simplement par un clic sur le bouton Run.

Il faut tout de même créer un compte sur le site replit.com puis aller à l'adresse du repl que j'ai créé puis cliquer sur le bouton Fork. Ensuite, on peut modifier à loisir le contenu du fichier ia_perso.py et du fichier ia_random.py avant de cliquer sur Run pour voir ce que donne la partie, avec l'affichage dans la console de l'ensemble des coups invalides et du score de fin de partie.

Je leur a également mis à disposition un tuto de 12 pages qui explique comment démarrer et qui explique quelques unes des fonctions utilisables dans une IA pour ce concours.
User avatar
AfyuVIP++
Niveau 15: CC (Chevalier des Calculatrices)
Niveau 15: CC (Chevalier des Calculatrices)
Level up: 97.1%
 
Posts: 396
Images: 52
Joined: 30 Oct 2019, 19:17
Gender: Male
Calculator(s):
MyCalcs profile
Class: plutôt, oui :)

Re: Résultats finale en équipe concours IA 1000 Bornes Pytho

Unread postby SlyVTT » 29 Jun 2024, 18:21

Hello,

désolé pour le délai pour revenir poster sur le fil. Nous avons mis quelques jours pour échanger entre nous et nous mettre d’accord sur le choix et la répartition du lot.

En tant que chef d’équipe, je tiens encore une fois à remercier les organisateurs du concours et tous les donateurs qui ont permis d'avoir de magnifiques lots pour les trois étapes de ce concours.

Nous voulons aussi redire un grand bravo à l'équipe des nsi42 et en particulier à Camille qui avait réussi à dépasser le maitre Cent20 et permettre à l'équipe de proposer une IA fonctionnant en équipe.

L'équipe des br.AI.n all.IA.ge est partie sur le lot TI-Nspire Intégral. Afin de ne pas avoir un message de 3km de long, j'envoie en parallèle à Critor un fichier avec la répartition des items retenus par les membres de l'équipe.

Encore une fois merci à tous, nous sommes fortement gâtés encore cette année.

Au nom de l'équipe,
Sly
Some works in progress :
The GUI Toolkit NF for nSpireMyShmup for fxCG-50Magic Light for Casio Graph 90+E
and
Magic Light for nSpire CX/CX-II
Simple Text Editor for nSpireOutRun for Casio Graph 90+E
95%
50%
100%
75%
100%
And more to come ... stay tuned
User avatar
SlyVTTPremium
Niveau 12: CP (Calculatrice sur Pattes)
Niveau 12: CP (Calculatrice sur Pattes)
Level up: 45.1%
 
Posts: 515
Images: 31
Joined: 19 Jan 2021, 09:41
Location: France
Gender: Male
Calculator(s):
MyCalcs profile
GitHub: SlyVTT

Re: Résultats finale en équipe concours IA 1000 Bornes Pytho

Unread postby critor » 30 Jun 2024, 07:50

Merci bien.

J'ai maintenant accès au document, je regarde tout ça.
Image
User avatar
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Level up: 45%
 
Posts: 41677
Images: 15208
Joined: 25 Oct 2008, 00:00
Location: Montpellier
Gender: Male
Calculator(s):
MyCalcs profile
YouTube: critor3000
Twitter: critor2000
GitHub: critor

Re: Résultats finale en équipe concours IA 1000 Bornes Pytho

Unread postby SlyVTT » 30 Jun 2024, 08:27

Super, c'est parfait.
Merci beaucoup.
Some works in progress :
The GUI Toolkit NF for nSpireMyShmup for fxCG-50Magic Light for Casio Graph 90+E
and
Magic Light for nSpire CX/CX-II
Simple Text Editor for nSpireOutRun for Casio Graph 90+E
95%
50%
100%
75%
100%
And more to come ... stay tuned
User avatar
SlyVTTPremium
Niveau 12: CP (Calculatrice sur Pattes)
Niveau 12: CP (Calculatrice sur Pattes)
Level up: 45.1%
 
Posts: 515
Images: 31
Joined: 19 Jan 2021, 09:41
Location: France
Gender: Male
Calculator(s):
MyCalcs profile
GitHub: SlyVTT

Re: Résultats finale en équipe concours IA 1000 Bornes Pytho

Unread postby critor » 30 Jun 2024, 21:31

Le colis d'Afyu a été complété et est normalement terminé.
Je partage une photo pour vérification avant envoi dès que possible.

Le colis de SlyVTT a été complété.
Désolé, l'autocollant "biquette l'exploratrice" a été épuisé par Yaya.Cout.
Dans la collection Cabri il ne me reste que "space biquette", que j'ai déjà mis dans le colis.
Tu souhaites choisir un autre autocollant TI à la place ?
Image
User avatar
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Level up: 45%
 
Posts: 41677
Images: 15208
Joined: 25 Oct 2008, 00:00
Location: Montpellier
Gender: Male
Calculator(s):
MyCalcs profile
YouTube: critor3000
Twitter: critor2000
GitHub: critor

Re: Résultats finale en équipe concours IA 1000 Bornes Pytho

Unread postby critor » 30 Jun 2024, 22:18

Le colis de TIny_Hacker a été commencé.

2 petits points à revoir également :
  • il me manque ton choix de clé USB
  • le stylo TI "Black with three silver stripes" a été épuisé par Yaya.Cout. Peux-tu en choisir un autre ?
Image
User avatar
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Level up: 45%
 
Posts: 41677
Images: 15208
Joined: 25 Oct 2008, 00:00
Location: Montpellier
Gender: Male
Calculator(s):
MyCalcs profile
YouTube: critor3000
Twitter: critor2000
GitHub: critor

Re: Résultats finale en équipe concours IA 1000 Bornes Pytho

Unread postby critor » 30 Jun 2024, 22:54

Le colis de Neotux a été commencé.

Pour le lot de groupe, il me manque :
  • le choix du stylo TI
  • le choix des 2 autocollants TI
Image
User avatar
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Level up: 45%
 
Posts: 41677
Images: 15208
Joined: 25 Oct 2008, 00:00
Location: Montpellier
Gender: Male
Calculator(s):
MyCalcs profile
YouTube: critor3000
Twitter: critor2000
GitHub: critor

Next

Return to News Divers

Who is online

Users browsing this forum: No registered users and 38 guests

-
Search
-
Social TI-Planet
-
Featured topics
"1 calculatrice pour tous", le programme solidaire de Texas Instruments. Reçois gratuitement et sans aucune obligation d'achat, 5 calculatrices couleur programmables en Python à donner aux élèves les plus nécessiteux de ton lycée. Tu peux recevoir au choix 5 TI-82 Advanced Edition Python ou bien 5 TI-83 Premium CE Edition Python.
Enseignant(e), reçois gratuitement 1 exemplaire de test de la TI-82 Advanced Edition Python. À demander d'ici le 31 décembre 2024.
Offre de test des nouveautés de rentrée 2024 par Casio. Enseignant(e), reçois gratuitement 1 exemplaire, à ton choix, de la Graph Light ou bien de la Graph Math+
14€ remboursés par Casio sur l'achat de ta calculatrice Graph 35 d'ici le 31 Octobre 2024
10€ remboursés par Casio sur l'achat de ta calculatrice Graph 90+E d'ici le 31 Décembre 2024
10€ remboursés par Casio sur l'achat de ta calculatrice Graph 25 d'ici le 31 Décembre 2024
8€ remboursés par Casio sur l'achat de ta calculatrice Graph Math+ d'ici le 31 Octobre 2024
Reprise de ton ancienne fx-92 Collège ou Graph 25/35/90 à 3€ peu importe son état. Même non fonctionnelle et donc invendable, même ancienne Graph 35 non conforme aux programmes (pas de Python), même ancienne Graph 25/35 inutilisable aux examens (pas de mode examen) et donc invendable. Etiquette de retour fournie, pas de frais de port à payer.
3€ remboursés par Casio sur l'achat de ta calculatrice fx-92 Collège d'ici le 30 Septembre 2024
5€ de remise immédiate sur l'achat de ta calculatrice TI-83 Premium CE Edition Python chez les revendeurs partenaires
4€ de remise immédiate sur l'achat de ta calculatrice TI-82 Advanced Edition Python chez les revendeurs partenaires
3€ de remise immédiate sur l'achat de ta calculatrice TI-82 Advanced chez les revendeurs partenaires
Comparaisons des meilleurs prix pour acheter sa calculatrice !
Aidez la communauté à documenter les révisions matérielles en listant vos calculatrices graphiques !
1234567891011121314
-
Donations / Premium
For more contests, prizes, reviews, helping us pay the server and domains...
Donate
Discover the the advantages of a donor account !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partner and ad
Notre partenaire Jarrety Calculatrices à acheter chez Calcuso
-
Stats.
1251 utilisateurs:
>1238 invités
>8 membres
>5 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)
-
Other interesting websites
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)