Блог

Для класса я должен написать функцию, которая принимает положительное целое число n и возвращает сумму нечетных цифр n в схеме. Пока что мой базовый вариант таков, что если n равно 0, то 0. Но я не уверен, как продолжить.

 (define sumOddDigits
     (lambda (n)
       (if (= n 0)
           0
  

Тестовые примеры:

 (sumOddDigits 0) → 0
(sumOddDigits 4) → 0
(sumOddDigits 3) → 3
(sumOddDigits 1984) → 10
  

Вы могли бы сделать это эффективно, используя один функциональный цикл:

 (define (sumOddDigits n)
  (let loop ([n n])
    (cond [(zero? n) 0]
          [else
           (let-values ([(q r) (quotient/remainder n 10)])
             (  (if (odd? r) r 0)
                (loop q)))])))
  

Получить список цифр можно с помощью следующей функции, которая использует ‘named let’:

   (define (getDigits n)
    (let loop ((ol '())            ; start with an empty outlist
               (n n))
      (let-values (((q r) (quotient/remainder n 10)))
        (if (= q 0) (cons r ol)
            (loop (cons r ol) q)))))
  

Тогда можно применить фильтр, используя odd? функция для получения всех нечетных элементов списка — и затем примените функцию ‘apply’ с ‘ ‘, чтобы добавить все эти элементы:

   (apply   (filter
            (lambda(x)
              (odd? x))
            digitList))
  

Полной функцией может быть следующее:

 (define (addOddDigits N)

  (define (getDigits n)
    (let loop ((ol '())
               (n n))
      (let-values (((q r) (quotient/remainder n 10)))
        (if (= q 0) (cons r ol)
            (loop (cons r ol) q)))))

  (define digitList (getDigits N))

  (println digitList)

  (apply   (filter
            (lambda(x)
              (odd? x))
            digitList)))
  

Тестирование:

 (addOddDigits 156)
  

Вывод:

 '(1 5 6)
6
  

Ваш базовый вариант равен, если n < 10. Потому что тогда вы находитесь на последней цифре. Затем вам нужно проверить, является ли оно нечетным, и если да, то вернуть его. В противном случае верните определитель сложения (0).

Если n > 10, вы вычтите первую цифру, затем проверьте ее на нечетность. Если нечетная, то добавьте ее к рекурсивному вызову, отправив частное от 10 (удаляет только что добавленную цифру). В противном случае вы рекурсивно вызываете add-odds с коэффициентом 10, не добавляя текущую цифру.

Здесь это в рекурсивной форме (Схема ЛЮБИТ рекурсию) :

 (define add-odds
  (lambda (n)
    (if(< n 10)
       (if(= (remainder n 2) 1)
          n
          0)
       (if(= (remainder (remainder n 10) 2) 1)
          (  (remainder n 10) (add-odds (quotient n 10)))
          (add-odds(quotient n 10))))))
  

Сначала получите (обратный) список цифр с простой рекурсивной реализацией:

 (define (list-digits n)
  (if (zero? n) '()
      (let-values ([(q r) (quotient/remainder n 10)])
        (cons r (list-digits q)))))
  

затем отфильтруйте нечетные цифры и суммируйте их:

 (define (sum-of-odd-digits n)
  (apply   (filter odd? (list-digits n))))
  

Примечание: (list-digits 0) возвращает '() значение, но оно подходит для последующего использования.

Более точная list-digits итеративная реализация (создает список цифр в правильном порядке):

 (define (list-digits n)
  (define (iter n acc) 
    (if (zero? n) acc
        (let-values ([(q r) (quotient/remainder n 10)])
          (iter q (cons r acc)))))
  (iter n '()))