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

[critor]

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 :

• principe du jeu : Edmond Dujardin
• graphismes du jeu : Jean-Yves Boucrot
• codage du jeu : Xavier Andréani alias critor
• test du jeu : Xavier Andréani alias critor + Adrien Bertrand alias Adriweb + RapidZapper
• plateforme en ligne de participation et duels entre IAs : Adrien Bertrand alias Adriweb + RapidZapper
• mises à jour spécifiques pour corriger des bugs ou contourner des problèmes de compatibilité apparaissant avec le jeu : Bernard Parisse alias parisse + Yaya.Cout + VittaScience
• firmware dédié à la compatibilité avec les NumWorks N0110 verrouillées et N0115/N0120 : RapidZapper
• principe de l'évaluation : noelnadal + Sébastien Michelland alias Lephe + Xavier Andréani alias critor
• bannières : Xavier Andréani alias critor + Sébastien Michelland alias Lephe
• dotation en lots : Texas Instruments + Casio + R. Jarrety S.A.S. + Calcuso + Université Grenoble Alpes + Vincent Robert alias cent20 + NumWorks + HP

Sommaire :

1. Les équipes invitées
2. La finale en équipe
3. Les IAs des équipes
4. Résultats

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 :

• Brain_Alliage_IA_1_Afyu
  En cas de victoire, cette IA s'exclame "Et BIM, c'est qui le meilleur ?"
• Brain_Alliage_IA_2_Sly
  En cas de victoire, cette IA s'écrie "Je suis SLYnapse-11.0 ... Moi en mode Truelle, je Maçonne "

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 10^e 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.

[SlyVTT]

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: Tout sélectionner

        # 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.

[Afyu]

Bravo Camille et l'équipe nsi42 !!
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.

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: Tout sélectionner

    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: Tout sélectionner

    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.
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 !).

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: Tout sélectionner

# 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 !!

[Afyu]

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.

[SlyVTT]

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

[critor]

Merci bien.

J'ai maintenant accès au document, je regarde tout ça.

[SlyVTT]

Super, c'est parfait.
Merci beaucoup.

[critor]

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 ?

[critor]

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 ?

[critor]

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