MPO 102 : nombres ondulants carrés

[gege]

Bonjour,
Un nombre ondulant est un nombre dont les chiffres alternent comme 121212 ou 63636 (définition qui n'est pas dans le dictionnaire !).
Le plus grand nombre ondulant qui est aussi un carré connu comporte 5 chiffres et commence par 6.
Quel est-il ?
Combien de nombre ondulants carrés connaît-on ?
A vos machines !!
G.E.

[ledudu]

Excellent, merci pour cette proposition de recherche.
Qu'est-ce qu'un carré connu ? Par exemple, moi, je n'en connais pas beaucoup.
Je connais 121

Je viens de comprendre c'est "le plus grand de ces nombres qui est aussi un carré" connu.


Deux points sur la forme.
1/ Il est demandé aux impétrants de mettre un lien vers le sommaire des MPO ce que je fais donc ci-dessous.
Sommaire des MPO

2/ Dans ce cas, cela t'aurait permis de voir que nous en sommes à 101 et que l'usage veut que les numéros suivent les éléments de la suite
u(n+1)=u(n)+1




Bonnes vacances

[dprtl]

Voici un premier programme Basic en 8 lignes, relativement court, pour Casio PB ou FX, il affiche 4 nombres en 1 minute environ ; avant de partir dans les nuages pour longtemps... longtemps

Code : Tout sélectionner

10 N=0
20 N=N+1:P$=STR$(N^2):L=LEN(P$)
30 IF L<4 THEN 20
40 A$=MID$(P$,2,1):FOR I=4 TO L STEP 2:IF A$<>MID$(P$,I,1) THEN 20
50 NEXT: IF L=4 THEN 80
60 A$=MID$(P$,3,1):FOR I=5 TO L STEP 2:IF A$<>MID$(P$,I,1) THEN 20
70 NEXT
80 PRINT P$;:GOTO 20

Le style de programmation est moche ('/mode mpo on'), mais je n'ai pas la fameuse "OM error" qui peut apparaître lorsqu'on empile les boucles ou les sous-programmes sans emprunter la sortie "normale".

[gege]

Bonjour,
Bien, mais ça ne va pas très vite...
En utilisant les chaînes de caractère et deux boucles imbriquées, ça marche bien, 0.4 secondes pour les 13 solutions sur HP Prime.
Je vais tester sur un Basic.
Bref, la principale difficulté est de construire les nombres ondulants...
G.E.

[C.Ret]

Code : Tout sélectionner

CAT MPO102     BASIC   94       07/10/21    11:10
              
10 FOR I=12 TO 98 @ IF NOT MOD(I,11) THEN 14
12 N=MOD(10101*I,1E5) @ R=SQRT(N) @ IF NOT FP(R) THEN DISP USING 16;N,R
14 NEXT I 
16 IMAGE K"=(",K")^2"

EDIT:
Avec ses 94 octets de force brute, met environ 5s pour afficher la solution ©@©@©=®©※^2 sur une HP-71B de base.

[gege]

Bonjour,
Super !
Il faudrait aussi trouver les 12 autres solutions.
1 minute 20 secondes sur FX-730P :

Code : Tout sélectionner

10 FOR I=1 TO 9
20 J=SQR(I):IF J=INT(J) THEN PRINT I;
30 NEXT I
40 FOR I=2 TO 5
50 FOR J=1 TO 9
60 FOR K=0 TO 9
70 $=STR$(J)+STR$(K):$=$+$:$=$+$:$=MID$(1,I)
80 A=VAL($):B=SQR(A)
90 IF B=INT(B) THEN PRINT A;
100 NEXT K:NEXT J:NEXT I

Je vais pirater ta méthode !
G.E.

[zpalm]

Salut, je passais sur le forum et ce MPO m'a titillé.

@gege, quand tu évoques 13 solutions est-ce que tu considères des nombres ondulants de moins de 3 chiffres? Parce-que suivant la définition de Wikipedia un nombre ondulant a au moins trois chiffres.

Ma contribution en une ligne sur HP Prime :

Code : Tout sélectionner

remove(0,MAKELIST(IFTE(ΠLIST(INSERT(EXECON("&3==&1",ASC(STRING(N^2))),1,1)),N^2,0),N,10,316))

[C.Ret]

@gege, quand tu évoques 13 solutions est-ce que tu considères des nombres ondulants de moins de 3 chiffres?

Oui, je pose la même question que zpalm car en commençant ma liste avec des nombres à trois chiffres, je ne trouve pas les douze autres !

Ma contribution en une ligne sur HP Prime :

Code : Tout sélectionner

remove(0,MAKELIST(IFTE(ΠLIST(INSERT(EXECON("&3==&1",ASC(STRING(N^2))),1,1)),N^2,0),N,10,316))

Euh! J'ai du mal à bien comprendre le principe, joli code en tout cas; on dirait vraiment du newRPL sur une HP Prime, mais je confirme que cela marche et j'obtiens les quatre mêmes ondulants d'au moins trois chiffres.

En extrapolant la définition et en considérant des nombres ondulants de moins de trois chiffres, j'obtient la liste suivante
☺=☺²,♀=☻², ♦=☼², ☺♠=♀², ☻♂=♂², ☼♠=♠², ♀♦=♣², ♠♀=♥², ♥☺=♦², ☺☻☺=☺☺², ♠♂♠=☻♠², ♀♥♀=☻☻², ♠♦♠♦♠=☻♠♀²
avec le code ci-dessous:

Code : Tout sélectionner

CAT MPO102     BASIC   115  07/10/21 16:15
10 FOR L=1 TO 5 @ P=10^L @ FOR I=MIN(12,P DIV 10) TO MIN(P-1,98) @ IF NOT MOD(I,11) THEN 14
12 N=MOD(10101*I,P) @ R=SQRT(N) @ IF NOT FP(R) THEN DISP USING 16;N,R @ PAUSE
14 NEXT I @ NEXT L 
16 IMAGE 7D"=",K"^2"

[gege]

Bonjour,
Pffff zêtes trop forts !
En effet il n'y a que 4 nombres de plus de 2 chiffres.
Voilà, ce MPO est plié !
Le prochain sera plus dur !!!

Je vais le taper sur des machines plus improbables.
Bravo !
G.E.

Edit : si vous trouvez un nombre ondulant de plus de 5 chiffres, vous serez célèbre... ça se tente non ?

[C.Ret]

Je vais le taper sur des machines plus improbables.

Il doit aussi y avoir moyen de faire plus court. Je suis en train de chercher comment le code de zpalm fonctionne et voir s'il n'y a pas moyen de le réduire un peu.

Et faire un une-ligne de BASIC me tente bien aussi.

[bernouilli92]

Voici un prog pour hp48 qui ne teste que les nombres à 5 chiffres :

Code : Tout sélectionner

« { } 
  1 9
  FOR I
  0 9
    FOR J
      IF I J ≠
      THEN 
        I 10 * J + 10 * I + 10 * J + 10 * I +
        IF DUP √ FP 0 ==
        THEN +
        ELSE DROP
        END
      END
    NEXT
  NEXT
»

[ledudu]

Ma contribution en une ligne sur HP Prime :

Code : Tout sélectionner

remove(0,MAKELIST(IFTE(ΠLIST(INSERT(EXECON("&3==&1",ASC(STRING(N^2))),1,1)),N^2,0),N,10,316))

Magnifique, tu peux expliquer ?

[zpalm]

Ma contribution en une ligne sur HP Prime :

Code : Tout sélectionner

remove(0,MAKELIST(IFTE(ΠLIST(INSERT(EXECON("&3==&1",ASC(STRING(N^2))),1,1)),N^2,0),N,10,316))

Magnifique, tu peux expliquer ?

L'idée de base c'est de tester tous les carrés d'au moins 3 chiffres et d'au plus 5 chiffres pour savoir s'ils sont ondulants.
100<=N^2<100000 => 10<=N<=336
Ensuite comme je voulais que ça tienne en une ligne le seul moyen de faire une boucle c'est avec MAKELIST.
Donc voici comment j'ai construit la séquence :

• transformer N^2 en chaîne de caractères: STRING(N^2)
• puis en liste de codes ASCII: ASC(STRING(N^2))
• comparer chaque élément n de cette liste avec le n+2, et générer une liste avec le résultat des tests, si le nombre est ondulant chaque test doit retourner 1: EXECON("&3==&1",ASC(STRING(N^2)))
• en faisant le produit de tous les résultats de test on doit avoir 1 si le nombre est ondulant ou 0 s'il ne l'est pas, mais ΠLIST ne fonctionne que sur des listes d'au moins 2 éléments et un nombre de trois chiffres EXECON retourne une liste d'un seul élément, donc on ajoute un '1' pour avoir au moins deux éléments: INSERT(EXECON("&3==&1",ASC(STRING(N^2))),1,1)
• on fait le produit pour savoir si le nombre est ondulant: ΠLIST(INSERT(EXECON("&3==&1",ASC(STRING(N^2))),1,1))
• s'il est ondulant on retourne N^2 sinon on retourne 0: IFTE(ΠLIST(INSERT(EXECON("&3==&1",ASC(STRING(N^2))),1,1)),N^2,0)
• on teste chaque carré entre 100 et 100000 et on construit une liste: MAKELIST(IFTE(ΠLIST(INSERT(EXECON("&3==&1",ASC(STRING(N^2))),1,1)),N^2,0),N,10,316)
• enfin on enlève les 0 pour ne garder que les carrés qui sont des nombres ondulants: remove(0,MAKELIST(IFTE(ΠLIST(INSERT(EXECON("&3==&1",ASC(STRING(N^2))),1,1)),N^2,0),N,10,316))

Voilà, l'idée était de proposer une solution differente des programmes classiques avec des boucles FOR ... NEXT.

[C.Ret]

Oui, bien joué, il n'y a pas de boucle FOR...NEXT dans ce "une-ligne" !

J'ai tenté de réduire un peu, la double boucle FOR..NEXT est cachée dans la construction de la matrice. L'idée et d'afficher la liste étendue des nombres ondulants carrés commençant donc à 0 et se terminant par la liste donné par zpalm.

Code : Tout sélectionner

UNION(mat2list(EXECON("&1*(FP(√&1)=0)",MAKEMAT(10101*I MOD ALOG(J),98,5))))

La liste n'est pas parfaitement triée, on peut éventuellement faire SORT(Ans) pour corriger, on retrouve les mêmes nombre ondulants carrés qu'avec mon dernier code pour HP-71B.

Corolairement, j'ai aussi trouvé une méthode plus courte et plus rapide pour le BASIC :

Code : Tout sélectionner

CAT MPO102     BASIC    67   07/10/21 19:07

10 FOR I=0 TO 98 @ R$=STR$(I*I) @ S$=R$[1,2] @ IF POS(S$&S$&S$,R$)=1 THEN DISP R$;" ";
20 NEXT I

On peut obtenir la liste restreinte en commençant la boucle à partir de 11, c'est en fait le même algorithme que la une-ligne de zpalm, mais avec une et une seule boucle FOR...NEXT explicite.

[ledudu]

Merci zPALM, c'est très clair.