Rechercher
 
 

Résultats par :
 


Rechercher Recherche avancée

Connexion

Récupérer mon mot de passe

Chatbox externe


Derniers sujets
» [JEU] Mon voisin du dessous
Mar 10 Oct 2017 - 19:42 par Wistaro

» Lancement du TI-Concours 2017 !
Sam 20 Mai 2017 - 0:27 par Paulo1026

» Chaînes Youtube des membres
Ven 19 Mai 2017 - 22:41 par Wistaro

» cacul du taux d'intêret
Ven 24 Mar 2017 - 21:50 par m@thieu41

» [Projet] Un mario by tout82
Dim 29 Jan 2017 - 14:09 par Wistaro

» Cherche documentation assembleur TI82stat
Mer 25 Jan 2017 - 12:29 par Ti64CLi++

» Probleme Ti-82 Stats fr
Jeu 12 Jan 2017 - 13:56 par Ti64CLi++

» ROM 82 stats.fr
Jeu 15 Déc 2016 - 10:24 par Ti64CLi++

» flappy bird
Jeu 15 Déc 2016 - 10:23 par Ti64CLi++

Partenaires
TI-Planet Espace-TI : Forum

Faire un don à Tout-82...
Où va cet argent ?
Membres donateurs:- Persalteas (10€)
- Wistaro (5€)
- jo2geek (22€)

Les posteurs les plus actifs du mois


Finale TI-Concours 2014 - travaux de Linkakro

Voir le sujet précédent Voir le sujet suivant Aller en bas

Finale TI-Concours 2014 - travaux de Linkakro

Message par Linkakro le Sam 10 Mai 2014 - 19:06

Je n'ai pas pu participer à la finale du TI-concours 2014 mais j'ai travaillé le sujet tout-de-même. Je vous présente des réflexions et solutions qu'on pourra discuter après.

Le sujet est disponible là.
mediafire.com ?o3hmi5486ty291o

###### q1
Soit P et N deux entiers naturels tel que N non nul. Trouver le plus grand P tel que 2^P
-- Solution mathématique : P < log2(N) = log(N)/log(2)= ln(N)/ln(2)
P doit être la partie entière du membre logarithme sauf si celui-ci est entier.
Mais cela se complique avec les erreurs de la calculatrice.
2^3=8
2^4=16
2^7=128
log2(7)~~2.807
log2(8 )==3
log2(9)~~3.1699
log2(15)~~3.9069
log2(16)==3.9999999999999
log2(17)~~4.087
log2(128)=7.0000000000001 // et poutant on doit répondre 6 pour 2^6<128
Parfois il faut prendre à l'inférieur et parfois non.
Donc round(log(N)/log(2),0) ne convient pas.
Je sens déjà venir le test manuel sans la fonction round. Laissons tomber.

-- Solution algorithmique.
Code:
Prompt N
1->P
While 2^P<N
P+1->P
End
P-1

###### q2

J'ai choisi de modifier le repère à ma guise pour dessiner un cercle qui apparaîtra comme une ellipse.
Code:
0->Ymin
0->Xmin
94*I/J->Xmax // met l'abscisse à l'échelle par rapport à l'ordonnée
62->Ymax
Circle(Xmax/2,31,I/2 // centreX,centreY,rayon

--Solution équation
Les points d'une ellipse (dans un repère défini par ses axes) sont les solutions de (X/a)^2+(Y/b)^2=1
Ne vous inquiétez pas des démonstrations, les énoncés dans un document comme Wikipédia suffiront.
On a l'axe abscisse 2a et l'axe ordonnée 2b.
On a pour notre problème I=2a et J=2b.
Donc on peut tracer
Y1=J/2*sqrt(1-(X*2/I)^2
Y2=-Y1
Centrez le repère en zéro, effacez les axes, forcez une échelle 1 sur la fenêtre, et le tour est joué.

###### q3

Le sujet est très ambigu. On veut un maximum de
Je considère que pour des poules de Q personnes on a L=1+int((N-1)/Q poules.
En effet avec k*Q personnes on peut avoir k poules de Q personnes, contrairement à ce qu'indiquait le sujet en termes de partie entière de N/7 avec poules de 7. Par ailleurs j'ai considéré que le nombre de participants dans chaque poule doit être le plus grand possible tant qu'on a pas quelques poules de Q personnes et une poule de rabiot de taille indéterminée.

Quoi qu'i en soit, on parcourt la table de gauche à droite et de droite à gauche pour les placer.
Par exemple en colonnes quatre poules et en données l'ordre de rangement.
1234
8765
9ABC

On doit déterminer le nombre de personnes de chaque poule.
Code:
Prompt N
7->Q
1+int((N-1)/Q->L // le nombre de personnes dans chaque poule
int(N/L->S
// le nombre de personnes dans les poules avant de répartir les derniers rabiots
N-LS->T
// nombre de personnes de rabiot à répartir dans la dernière ligne de poules
fPart(N.5/L
// savoir si la dernière ligne est de gauche à droite ou de droite à gauche
seq(X<=T and Ans or X>L-T and not(Ans),X,1,L
// répartition des rabiots, est générant des nombres 1 en face des personnes
S+Ans
//ajout du nombre moyen de personnes au compte de la dernière ligne (Ans est la liste générée par seq(), donc cela ajoute S à chaque terme)

###### q4

Avant de commencer songez que les listes de la calculatrice commencent à 1, donc il y a des ajouts de "+1" et "-1" un peu partout dans les calculs de position.

On garde le tri des ages comme ceci.
Code:
Prompt L2 // ages
dim(L2->M //nombre de personnes
7->Q
1+int((M-1)/Q->L // nombre de poules
Prompt N
seq(X,X,1,M->L1 // identifiants des personnes
SortD(L2,L1 // tri par les ages
ClrList L3
Puis on ajoute la répartition des personnes en parcourant la liste des identifiants.

Ma première idée étudie toute la table des poules. Mais comme on veut une poule seulement, je conserve une seule colonne.
Code:
Prompt L2 // ages
dim(L2->M //nombre de personnes
7->Q
1+int((M-1)/Q->L // nombre de poules
Prompt N
seq(X,X,1,M->L1 // identifiants des personnes
SortD(L2,L1 // tri par les ages
ClrList L3
0->X // colonne du tableau (sera incrémenté aussitôt)
1->Y // ligne du tableau
1->Z // sens de parcourt
For(W,1,M
X+Z->X // déplacement horizontal
If X>L or not(X // sortie du tableau par l'horizon
Then
Y+1->Y // prochaine ligne
-Z->Z // changement de sens
X+Z->X // revient dans le tableau
End
If X=N // la colonne désirée
L1(W->L3(Y // stockage
End
L3 // la liste des identifiants dans la poule N
Ensuite je veux restreindre la recherche en parcourant les lignes de la table et déterminent l'indice de participant correspondant.
D'où seconde idée : déterminer un terme par symétrie de la position précédente avec la fin de la ligne.
Code:
____123456789ABC
CBA98765________
____9ABC________
Je veux la symétrie de W avec la fin de la ligne "a" car cela permet d'atteindre la ces de la ligne en dessou à la même colonne malgré le changement de sens de parcourt horizontal.
Cette symétrie se traduit par 1+2a-W->W avec "a" la fin de la ligne
Le plus pénible est le calcul de ce "a"
Code:
2L-N->Z
Repeat W>M
L1(W->L3(Y
  // formule par décalage 1+2L(1+int((W-1)/L))-W->W
// formule par opposition (l'inférieur de l'opposé est l'opposé du supérieur)
1-2Lint((1-W)/L-W->W

Y+1->Y // prochaine ligne
End
L3
troisième idée :symétrie de même mais utiliser la ligne pour calculer la fin de la ligne, c'est bien plus commode.
Code:
N->W
1->Y
Repeat W>M
L1(W->L3(Y
1+2LY-W->W
Y+1->Y
End
L3
quatrième idée : utiliser un pas d'incrément qui soit complémenté à chaque itération.
Code:
N->W
1->Y
L+1-N->Z
Repeat W>M
L1(W->L3(Y
W+2Z-1->W // avance du pas
L+1-Z->Z // complémentation du pas
Y+1->Y // prochaine ligne
End
L3

###### q5

Un tableau N*N de résultats de N personnes contre N-1 autres personnes de la même poule.
Il faut trier suivant les moyennes de résultats et la fréquence de victoire.

Puisqu'on classe toujours avec des moyennes et fréquences sur un même dénominateur, je me contente de compter les effectifs, je me moque des valeurs relatives des moyennes et fréquences.

Il y a des termes fixés à zéro dans la diagonale (X,X). Donc la moyenne n'est pas influencée. Donc je peux calculer la moyenne d'une liste et modifier le coefficient pour N-1 personnes.
N/(N-1)*mean(L1)=moyenne de N-1 valeurs
exemple (x+y+z+0)/4 = (x+y+z)/3*3/4

Pour placer une ligne de la matrice tableau en liste, je transpose la matrice et extrait la colonne correspondante.
Matr>list([A]t,W,L1
t est le symbole dans le menu matrice

Pour déterminer le vainqueur d'un combat, il faut comparer une case (W,V) avec une case (V,W) pour W et V différents.
**Technique 1 : restreindre la recherche à la moitié supérieure à la diagonale et analyser la victoire ou la défaite. Cela demande deux cas d'analyse des des conditions sur la position dans la table.
**Technique 2 : puisqu'on veut classer les personnes, ce n'est pas important de compter chaque combat une seule fois. Donc les conditions sur les positions sont omises et on compte finalement deux fois chaque combat, et analyse à la fois victoire et défaite
**Technique 3 : se contenter d'analyser uniquement la victoire ou uniquement la défaite et parcourir toute la table. Cela compte uniquement la victoire d'une personne.

Remarque : puisqu'il n'y a jamais égalité dans les deux résultats d'un combats, alors l'inégalité stricte suffira toujours.

Autre optimisation 1 : on peut inverser des coordonnées ou des conditions pour permettre que la matrice soit transposée une seule fois au début du programme. Je ne l'ai pas fait.

Les combattants voient leur résultats sur la ligne de leur identifiant. Je parcours la matrice en lignes.

La calculatrice ne trie que pour un critère. Puisque je veux trier suivant deux critères et donner priorité à l'un d'eux, j'ajoute une liste à l'autre avec un coefficient que rend le critère secondaire négligeable devant le principal.
J'ai choisi le coefficient 0.01 car je suppose les effectifs entiers et inférieurs à 100.

Code:
Prompt [A]
dim([A]
Ans(1->N
ClrList L2
N->dim(L2
L2->L3 // histoire d'économiser les dimensions et vidage
For(W,1,N
Matr>list([A]t,W,L1 // acquérir une ligne
 // la moyenne avec N-1 personnes à partir de N termes
 // N/(N-1)mean(L1->L3(W
sum(L1->L3(W // la somme pour classer (au lieu de la moyenne)
For(V,1,N
If V-W // V différent de W donc pas diagonale
Then
If [A](W,V)>[A](V,W // victoire de celui sur la ligne W
1+L2(W->L2(W // compte de la victoire du combattant W
End
End
End
seq(X,X,1,N->L1 // liste des identifiants
.01L3+L2->L2 // rend un second critère présent mais négligeable
SortD(L2,L1,L3 // tri
L1 // identifiants triés

###### q6
Tri suivant deux critères dont un négligeable. Comme la question 5. Le coefficient est 0.00001 car les données sont les moyennes et fréquences donc je prévoie au moins 4 chiffres de départage du premier critère.
Code:
Prompt L1,L2,L3
dim(L1->N
seq(X,X,1,N->L4
L2/10000+L1->L1
SortD(L1,L3,L4,L2
L3->L5
Pause L4
Pause L5
###### q7

J'associe une valeur à chaque chaîne suivant l'écriture des nombres en base 27 pour supporter 26 lettres différentes de valeur associée non-nulle.
Je stocke les chaînes dans une seule chaîne et les sépare par des caractères interdits, "0".
Puis je tri avec les listes.
Puis je recherche chaque chaîne stockée avec inString et une boucle.

J'ai choisi de les séparer et retrouver avec des "0" pour ne pas avoir de limitation de nombre de chaînes.
Sinon j'aurais pu stocker des adresses de début et fin de chaînes. Dans des listes cela limiterait à 999 (ou 99 sur TI82)

Avec la base 27, des mots de 9 caractères maximums seront toujours différenciés. Plus de caractères ne garantira pas une distinction.
En effet la calculatrice supporte 14 chiffres de mantisse et la fonction de tri les utilise tous.

J'ai choisi la base 27 car elle ne nécessite pas de décalage des valeurs 1-26 à 0-25 et que la base 26 ne permet pas plus de caractères par mot qui soit systématiquement distinct.
14/log(26)~~9.8941
14/log(27)~~9.7808

Code:
ClrList L2
Prompt N
"0->Str2
For(W,1,N
Input Str1
0
For(A,1,length(Str1
Ans+27^(N-A)*inString("ABCDEFGHIJKLMNOPQRSTUVWXYZ",sub(Str1,A,1
End
Ans->L2(W // assignation d'une valeur à la chaîne
Str2+Str1+"0"->Str2 // stockage et séparation
End
seq(X,X,1,N->L1 // liste d'identités
SortA(L2,L1 // tri croissant alphabétique
// ci-dessous W est l'ordre de classement et L1(W) sera l'identité de la chaîne classée à l'ordre W.
For(W,1,N // parcourt de la liste des identités triées
// ci-dessous recherche de la chaîne d'identité L1(W)
2->C
0->A
While A<L1(W
C->B
1+inString(Str2,"0",C->C
A+1->A
End
// ci-dessous affichage de la chaîne trouvée
Pause sub(Str2,B,C-B-1
End

-------
Je travaille depuis quelques heures pour décomposer caractère par caractère le problème des comparaisons de chaînes, et décomposer le tri en une recherche par saisie.
J'ai eu une difficulté théorique avec les chaînes de taille différentes mais qui commencent pareil.
Je veux permettre un nombre de caractères illimité pour égaler les propos de Persalteas en commentaire de l'annonce du TI-Concours 2014 page 8.

Voici ce que j'ai écris pour l'instant, et que je dois vérifier.
Code:
Prompt N
"ABCDEFGHIJKLMNOPQRSTUVWXYZ->Str4
Input Str2 // première chaîne
"0"+Str2+"0->Str2 // stockage

For(W,1,N-1 // saisie de chaque chaîne et son tri élémentaire
Input Str1
length(Str1->L
2->C
2->D // si la saisie doit aller au début
1->A
Repeat A>W or Ans>0   // idée pour écourter : or L<M and not(Ans
// parcourt des chaînes précédentes jusqu'à la première chaîne supérieure à la saisie Str1

//acquisition de la chaîne précédente d'ordre A en mémoire
C->B
1+inString(Str2,"0",C->C
sub(Str2,B,C-B-1->Str3

//détermine si la chaîne en mémoire est supérieure à la saisie
length(Str3->M
1->F
Repeat F>L or F>M or Ans
F+1->F
inString(Str4,sub(Str3,F,1)) - inString(Str4,sub(Str1,F,1))
End // fin F

// Ans représente la condition que le dernier caractère analysé est décisif
// Le signe de Ans permet de classer : Ans>0 signifie que la mémoire est supérieure à la saisie

If Ans<0 or L=>M and not(Ans
C->D
// conserve la position de fin de la chaîne incluse ou inférieure (ou le début de la prochaine pour être exact)
// Donc à la fin cela représentera la fin de dernière chaîne incluse ou la dernière chaîne inférieure s'il n'y a pas d'incluse.
// Cela supporte aussi d'insérer au début de la mémoire Str2 puisque D est initialisée avant la boucle While du A.
// Comme D reçoit la dernière fin de chaîne repérée, l'insertion est correctement positionnée même à la fin de la mémoire Str2

A+1->A
End // fin While du A

// action d'insertion
// insère avant la première chaîne supérieure mais après la chaîne incluse
sub(Str2,1,D-1)+Str1+sub(Str2,D-1,length(Str2)-D+2)->Str2
// triche pour ajouter un zéro puisque le début et la fin se chevauchent pour avoir un zéro en plus

End // fin de saisie et tri élémentaire

//afficher les chaînes
commentaire insertion:

Code:
petits schémas pour montrer la tricherie de l'insertion qui ajoute un zéro avec deux sous-chaînes qui se chevauchent.
////////
//0__a0b0c0
//p________
//q__qqqqqq
//pzqqqqqqq
//0z0a0b0c0
////////
//0a0b0c0__
//ppppppp__
//______q__
//pppppppzq
//0a0b0c0z0
////////
//0a0__b0c0
//ppp______
//__q__qqqq
//pppzqqqqq
//0a0z0b0c0

__________________________________________________________________________
Vétéran du TI-Basic Zilog80. Ti82statfr sur Tout82 depuis 2009 et ti84pocketfr depuis noël 2012. Ti83plusfrUSB (été 2014, concours tiplanet suite du geek). Bidouille un peu d'assembleur Z80.
Incappable de gérer le temps et manque de tact, plutôt serviable.
Je prend les commandes de programme. Je suis motivé par les maths et la physique tant que ce n'est pas une simple copie d'antisèche.
Vous pouvez trouver une grande partie de mes données hébergées dans mon mediafire. Le ZIP et la liste sont périmées depuis longtemps.
coucou Invité What a Face
avatar
Linkakro
----------------------
----------------------

Messages : 533
Points Concours : 55
Productivité : 31
Date d'inscription : 30/07/2013
Localisation : origine région centre, puis perpignan
Calculatrice(s) :
  • TI-82 Stats.fr

. : TI-82 Stats.fr

Voir le profil de l'utilisateur

Revenir en haut Aller en bas

Voir le sujet précédent Voir le sujet suivant Revenir en haut


 
Permission de ce forum:
Vous ne pouvez pas répondre aux sujets dans ce forum