[Mini Challenge Basic #16] Comparaison déraisonnable

[Bisam]

Les vacances approchent... et avec elles reviennent les Mini-Challenges !

Pour ce 16ème mini-challenge, je vous propose de créer une fonction compare(n,p) qui prend en arguments deux nombres entiers positifs et qui les comparent... mais pour un ordre inhabituel. La fonction devra renvoyer les mêmes résultats que la fonction suivante :

Code: Tout sélectionner

string(n)≤string(p) → compare(n,p)

Cependant, on oblige à ne pas se servir de chaînes de caractères !!

Le critère qui sera privilégié sera la taille en nombre d'octets de votre code.

Bonne chance à tous.

[critor]

Ordre lexicographique sur les nombres donc.

Voici une petite proposition rapide qui semble marcher :

Code: Tout sélectionner

Define compare(n,p)=
Func
While n≥10
  n/10→n
EndWhile
While p≥10
  p/10→p
EndWhile
While n+p>0
  If int(n)<int(p)
    Return true
  If int(n)>int(p)
    Return false
  10*fPart(n)→n
  10*fPart(p)→p
EndWhile
Return true
EndFunc

(207 caractères)

Petite question sur la comptabilisation des octets.
Si on saisit 10fPart(n), la calculatrice corrige automatiquement après parsing ent 10*fPart(n).
Faut-il donc compte 10 ou 11 octets ?

La question peut sembler ridicule, mais elle est importante si on envisage d'optimiser avec un logarithme décimal.
Car si on saisit log(n), la calculatrice corrigera automatiquement en log(n,10).
Donc là, 6 ou 9 octets, à multiplier par le nombre de logarithmes, ça peut changer bien des choses...

Merci pour ce superbe défi.

[critor]

Petite amélioration toujours sans logarithme :

Code: Tout sélectionner

Define compare(n,p)=
Func
While n≥10
  n/10→n
EndWhile
While p≥10
  p/10→p
EndWhile
While int(n)=int(p) and n+p>0
  10*fPart(n)→n
  10*fPart(p)→p
EndWhile
Return int(n)≤int(p)
EndFunc

(175 caractères)

[Bisam]

Ça commence très fort !

J'ai cru avant de tester qu'il y aurait un problème si un des nombres de départ avait trop de chiffres : il me semblait que tes 10*fpart(..) perdraient une partie du nombre en convertissant en réel... mais ils ne le font pas. Ils conservent les fractions et donnent les bons résultats, même avec des nombres très grands !

Bien joué.

Pour ce qui est de l'évaluation du nombre d'octets, je pense qu'il faut compter APRÈS la vérification du code.

À présent, qui dit mieux ?

[Adriweb]

Bizarrement, le code de critor me jète avec une erreur de syntaxe que je ne comprends pas vraiment sur le n/10→n...
J'ai réécrit la ligne, au cas où, pareil.
Tenté aussi Programme/Fonction LibPub ou non, pareil.

[Bisam]

Tu as essayé de réécrire la ligne précédente aussi ?
C'est peut-être le symbole ≥ qui pose problème dans ton copier-coller.

[Ti64CLi++]

Super, je vais essayer ce mini-défi ^^

[Excale]

Je dois avouer que je n'ai pas testé en détail la correction de cette fonction.

Code: Tout sélectionner

Define compare(n,p)=
Func
If n>p
10*n+1→n
ifFn(p*n=0,n=0,n*10^(int(log(p,10))-int(log(n,10)))≤p)
EndFunc

(avec cette méthode, les cas particuliers coûtent cher)

[Bisam]

Je pense que cette fois-ci ça ne marche pas du tout avec les nombres très grands et proches l'un de l'autre.

Si on omet ce détail, on peut simplifier la fonction ainsi :

Code: Tout sélectionner

when(p*n=0, n=0, fpart(log(n,10))≤fpart(log(p,10))) → compare(n,p)

[Excale]

Je pense que cette fois-ci ça ne marche pas du tout avec les nombres très grands et proches l'un de l'autre.

Si on omet ce détail, on peut simplifier la fonction ainsi :

Code: Tout sélectionner

when(p*n=0, n=0, fpart(log(n,10))≤fpart(log(p,10))) → compare(n,p)

Ça marche pas pour compare(420, 42).

D'autre part, je n'utilise à aucun moment les flottants. Donc soit le CAS les utilise en interne* et peut donc effectivement se 'tromper', soit ça marche pour les grands nombres.

*Peut-être qu'il 'float' avant de faire le 'int()'.