La récursivité (ou les boucles "while") dans le Schéma

(define (orderedTriples n)
(set! i n)
(set! j n)
(set! k n)
(while (>= i 0)
   (while (>= j 0)
     (while (>= k 0)
       (printf "(~a, ~a, ~a)" i j k) 
       (set! k (- k 1))) 
     (set! j (- j 1))) 
  (set! i (- i 1))))

Donc ma question est...je suis confus quant à la façon de faire des boucles while de travail dans le schéma (je suis très nouveau à cette sorte d'excuse de la syntaxe si je suis loin). J'ai tapé tout ici juste dans le but de travailler par l'intermédiaire d'un problème et de montrer ce que je suis en train d'accomplir. Quelqu'un pourrait-il m'aider avec un simple exemple de récursivité imbriquée ou la récursivité?

InformationsquelleAutor ellie0414 | 2013-02-03
  1. 5

    Selon le Régime de l'interprète en cours d'utilisation, il existe plusieurs façons de mettre en œuvre les boucles. Par exemple, dans la Raquette, c'est aussi simple que l'utilisation de itérations et des compréhensions:

    (define (orderedTriples n)
  (for* ([i (in-range n -1 -1)]
         [j (in-range n -1 -1)]
         [k (in-range n -1 -1)])
    (printf "(~a, ~a, ~a)" i j k)))

    Le style de programmation de la question (en supposant qu'il a travaillé) est fortement déconseillée dans le Schéma - utilisation de mutation (la set! opération) pour la lecture en boucle est un gros no-no, c'est comment vous pouvez résoudre le problème dans un C-comme le langage, mais dans le Schéma en particulier (et en Lisp en général) il y a d'autres constructions pour la mise en œuvre de l'itération dans un programme (la solution donnée par @TerjeD illustre l'utilisation de do, par exemple), et même si de telles constructions n'existait pas, une solution récursive ou une solution à l'aide de d'ordre supérieur procédures serait préférable. Par exemple, voici une autre solution possible, à l'aide de imbriqués les mappages avec seulement des procédures standard (à l'exception de printf, qui est non-standard):

    (define (range n)
  (if (negative? n)
      '()
      (cons n (range (- n 1)))))

(define (orderedTriples n)
  (for-each (lambda (i)
              (for-each (lambda (j)
                          (for-each (lambda (k)
                                      (printf "(~a, ~a, ~a)" i j k))
                                    (range n)))
                        (range n)))
            (range n)))
    • C'est VRAIMENT utile! Merci!
    InformationsquelleAutor Óscar López
  2. 3

    Vous pouvez utiliser le do boucle, ce qui est écrit comme ceci (pour la boucle interne de votre fonction):

    (do ((k n (- k 1)))               ; variable, initialization, and updating form
   ((< k 0))                      ; stop condition, and optionally return value
  (printf "(~a, ~a, ~a)" i j k))  ; body forms

    Voir http://www.schemers.org/Documents/Standards/R5RS/HTML/r5rs-Z-H-7.html#%_idx_138 pour de plus amples informations sur la do itération de construire.

    InformationsquelleAutor Terje D.
  3. 1

    Si vous aviez, vous pouvez le faire avec la récursivité.

    (define (ordered-triples n)
  (let iloop ((i n))
    (unless (negative? i)
      (let jloop ((j n))
        (unless (negative? j)
          (let kloop ((k n))
            (unless (negative? k)
              (printf "~a ~a ~a\n" i j k)
              (kloop (sub1 k))))
          (jloop (sub1 j))))
      (iloop (sub1 i)))))

    Bien sûr, il est plus facile d'utiliser la Raquette de for* boucle.

    InformationsquelleAutor to_the_crux