Discussion :

[schwarzyk]

Bonjour,

J'ai reçu ceci comme exercice et étant débutant j'ai énormément de mal.

Créez une fonction effectuant la somme des N premiers nombres.

L'affichage du résultat se fera au moyen de la fonction Alert dont la syntaxe est la suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

(Alert chaine_de_caractères)

Exemple : (Alert "Bonjour").

Pouvez vous m'aidez ?

Pour le moment j'ai ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
(defun sommenpremiers (/ numero resultat)
    (setq numero (getreal "Valeur de N svp ?"))
    (setq resultat 0)
    (while (> numero 0)
        (progn
            (setq resultat (+ resultat numero))
            (setq numero (- numero 1))
            (setq resultat resultat)
        )
    )
)

Un grand merci d'avance.

[Lud0o]

Tu devrais déjà préciser ce que tu entends par N premier nombre : tu veux faire un sigma sur des nombres premiers ? ou un sigma de 0 à N ?
Si tu travailles sur des nombres premiers, il te manque une fonction qui va soit vérifier si le nombre courant est premier (placé dans une boucle, par exemple), ou qui va te retourner une liste de N éléments qui seront des nombres premiers.

***

ps : utilise la balise [code], le dièse sur l'éditeur. Ca te permettra de garder une indentation sur le code, présentement pas très lisible.

[schwarzyk]

Bonjour et merci de la réponse

Il s'agit des premiers nombres 1,2,3,4,5,6, etc) et non pas des nombres premiers (2,3,5,7,11,etc)

En gros je dois lancer la fonction et elle doit me demander N (étant le nombre de fois que je vais faire l'opération)

Exemple N=3 j'aurais 3 + 2 +1

Voilà voilà

Mais pour cette histoire de Alert, je n'y arrive pas...

[Bruno-Vdh]

Bonjour,

Certainement avec retard (je suis peu présent sur ce forum) pour ton exercice. Il me semble reconnaitre la syntaxe de l'AutoLisp, je vais donc m'essayer à une réponse.

Pour la fonction alert regarde du coté des fonctions de conversions dans ton cas rtos (real to string).
Pour rester dans ton exemple, j'ai monté un petit exemple avec getint (qui me semble plus adapté) pour travailler avec des entiers et itoa pour effectué la conversion en chaine de caractère.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
(defun sommenpremiers (/ numero resultat)
  (setq numero   (getint "Valeur de N svp ?")
        resultat 0
  )
  (while (> numero 0)
    (setq resultat (+ resultat numero)
          numero   (1- numero)
    )
  )
  (alert (itoa resultat))
)

Pour plus de souplesse (même si ce n'est qu'un exercice), j'aurais plutôt scindé mon code comme ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
(defun Snp (int / res)
  (setq res 0)
  (while (> int 0)
    (setq res (+ res int)
          int (1- int)
    )
  )
  res
)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

(defun sommenpremiers () (alert (itoa (Snp (getint "Valeur de N svp ?")))))

Et pour faire plus "lispiens", on peut également écrire Snp sous forme récursive comme ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
(defun Snp (int)
  (if (> int 0)
    (+ int (Snp (1- int)))
    0
  )
)

Pour la petite histoire, c'est avec ce raisonnement par récurrence S = 1 + 2 + 3 + ... + (n-1) + n que le petit Carl Friedrich Gauss (âgé de neuf ans à l'époque) à déduit la formule suivante S= n(n+1)/2, concernant la somme des N premiers entiers naturels.


Formule qui une fois écrit en lisp (c.a.d en notation préfixé) donne ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
(defun Snp (n)
  (/ (* n (1+ n)) 2)
)

Cordialement,

[Kurodiam]

Donc il est possible de créer sous Common lisp : une fonction qui intègre la raison r d'une suite par exemple arithmétique ...

Pourquoi mettons en lisp la division avant la multiplication ? Vous trouvez que c'est un peu tordu ...

[jack-ft]

Pourquoi mettons en lisp la division avant la multiplication ? Vous trouvez que c'est un peu tordu ...

Ben, parce qu'il vaut mieux multiplier AVANT de diviser!

Quand on veut diviser n * (n + 1) par 2, on ne sait pas lequel de n et n+1 est pair!
On ne peut donc pas diviser avant de multiplier, car on risquerait d'avoir un arrondi ou une troncature (à moins que les rationnels soient correctement gérés!).

Remarque qu'en français, l'expression n*(n+1)/2 se lit comme:
"la division du produit de N et de l'ajout de 1 à N par 2" qui respecte exactement l'ordre utilisé par lisp (/ (* n (1+ n)) 2) (notation préfixée)

(c'était comme ça que les maths étaient enseignées avant l'invention de la notation infixée!)

En mathématiques, on utilise plus volontiers la notation infixée (avec tout le problème des priorités d'opérateurs):
'N fois, entre parenthèses, N plus 1, le tout divisé par 2"

En forth (ou postscript), on aurait quelque chose comme:
"N N 1 + * 2 /"

[Kurodiam]

Merci ^^

C'est vrai que l'expression en français est bien transcrite en lisp .

[jack-ft]

Et pour faire plus "lispiens", on peut également écrire Snp sous forme récursive comme ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
(defun Snp (int)
  (if (> int 0)
    (+ int (Snp (1- int)))
    0
  )
)

Pour faire encore plus lispien, on peut mettre le test de fin avant la récursivité (et regrouper les fermantes!):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
(defun somme-n (int)
  (if (<= int 0)
    0
    (+ int (somme-n (1- int)))))

À noter que ce code n'est pas récursif terminal (à cause de l'accumulation des int dans la pile).
(pour plus de détails, voir l'article sur la récursion terminale).

[Bruno-Vdh]

Pour faire encore plus lispien, on peut mettre le test de fin avant la récursivité (et regrouper les fermantes!):

Oui effectivement, pour plus de lisibilité même dans un if, il est d’usage de mettre la condition d’arrêt avant la récursivité. Pour les fermantes hélas mon IDE ne le fait pas (en fait j’utilise l'IDE intégré à AutoCAD). J’emploie un dialecte lisp très simplifié, je ne programme pas en CL… D’ailleurs je ne suis pas programmeur, seulement un dessinateur industriel (amateur et autodidacte en LISP).

Si tu connais une version de Common Lisp libre avec IDE et facile à installer sous Window Seven cela m’intéresse, merci.

[jack-ft]

Pour les fermantes hélas mon IDE ne le fait pas (en fait j’utilise l'IDE intégré à AutoCAD). J’emploie un dialecte lisp très simplifié, je ne programme pas en CL… D’ailleurs je ne suis pas programmeur, seulement un dessinateur industriel (amateur et autodidacte en LISP).

Si tu connais une version de Common Lisp libre avec IDE et facile à installer sous Window Seven cela m’intéresse, merci.

Hum...

Je ne connais pas bien autocad (je ne l'ai utilisé qu'une fois il y a 15 ans) et je connais encore moins les particularités de son langage Visual-Lisp et de son IDE, qui semble être Vlide.
Peut-être y a-t-il des options ou des plugins qui permettent de gérer les parenthèses dans Vlide (il y a quelques références sur internet).

Si tu DOIS programmer en autolisp, une solution Common Lisp risque de ne pas bien marcher car:

• la syntaxe peut être différente. Par exemple, il peut avoir du mal avec (defun yinyang (/ origin radius i-radius half-r origin-x origin-y) car le "/" ne peut pas être utilisé pour définir des variables locales en CL.
• il ne connaitra pas les fonctions spécifiques à autolisp (comme "command" (si je ne m'abuse)).

Si tu dois programmer en autolisp, tu peux néanmoins, pour éditer ton code, utiliser un autre outil (comme NotePad++ ou, la rolls des éditeurs (ou des IDE), emacs (gratuit et facile à installer!)).
Une recherche google avec "emacs autolisp" donne 187 000 références...

Dans l'article http://forums.autodesk.com/t5/visual.../td-p/3873265#, martti.halminen indique qu'il n'utilise VLIDE que pour compiler et débeuguer et qu'il utilise emacs pour l'édition (il existe d'ailleurs un mode emacs auto-lisp-mode spécifiquement pour éditer de l'autolisp).

Si tu veux juste faire des exercices en lisp, tu peux aussi utiliser l'autre lisp intégré d'emacs: emacs-lisp et son interprète (M-x ielm RET).

De plus, si tu connais déjà un peu lisp, tu peux aussi faire plein de manipulations intéressantes en créant et ajoutant à emacs de nouvelles fonctions écrites en emacs-lisp.

Lorsque je faisais jadis du Common Lisp, j'utilisais un interprète dans une fenêtre ouverte dans emacs. De cette manière, si tu veux programmer en CL, tu peux utiliser, par exemple, un interprète Clisp lancé dans une fenêtre emacs.

[Bruno-Vdh]

Bonjour jack-ft

Une recherche google avec "emacs autolisp" donne 187 000 références...

Oui c’est vrai je m’en étais déjà rendu compte suite à la réponse que tu m’avais déjà fait ici même
http://www.developpez.net/forums/d10...z/#post5733824

Et de mémoire je m’étais un peu perdu dans toutes ces références et implémentations, n’étant pas issue du monde du développement, il y a tout un vocable spécifique qui m’est étranger.. Bref je n’avais pas trouvé cela aussi facile à installer, peut-être ne suis-je pas tombé sur les bonnes références.

Sinon pour ce qui est des particularités du langage AutoLISP/Visual-Lisp depuis le temps j’ai appris à les maitriser en fréquentant des forums spécifiques à ce dialecte. Pour ce qui est de l’IDE Vlide il me convient bien, mais la programmation AutoLISP oblige l’exécution sous AutoCAD qui possède l'interprèteur… C’est un peu dommage lorsque l’on écrit une routine qui ne nécessite pas de s’exécuter sous AutoCAD.

De plus pour ma culture personnel, je voudrais bien continuer à me confronter avec des concepts plus avancés comme les macro fonctions, les listes circulaires etc.. Tous ces notions que je vois parfois débattu sur ce forum et auquel je n’ai pas accès avec AutoLISP.

Donc voilà si quelqu’un d’initié pouvait me réduire les 187 000 références de google, à un ou deux choix pertinent, je lui en serai reconnaissant.

Merci et A+ Bruno