Comments on: Scheme code kata

By: Richard Loveland

Richard Loveland — Sat, 25 Feb 2012 13:41:26 +0000

Many years later, I’ve discovered this post. My solution (inspired by Brian Harvey’s from the abovementioned thread in c.l.s):

(define (p->a p)
(cond ((null? p) ‘())
((symbol? (car p))
(cons (list (car p)
(gather-next-batch number? (cdr p)))
(p->a (cdr p))))
(else (p->a (cdr p)))))

(define (gather-next-batch pred seq)
(cond ((null? seq) ‘())
((pred (car seq))
(cons (car seq)
(gather-next-batch pred (cdr seq))))
(else ‘())))

By: A Scheme Code Kata « the logic grimoire

A Scheme Code Kata « the logic grimoire — Fri, 24 Feb 2012 14:37:08 +0000

[...] beware! This is a meta-creature, a post about a post about a post. By way of comp.lang.scheme, the musings of the great jao (who incidentally is the Wizard behind Geiser (which is the way to Scheme with Emacs these days)), [...]

By: msingh

msingh — Wed, 23 May 2007 07:16:50 +0000

; i noticed that the reverse is nicer to work with:
; [4]> (reverse ‘(a 1 2 3 b 4 5 c d 8 9 e))
; (E 9 8 D C 5 4 B 3 2 1 A)

(defun kata (list)
(let ((list* (nreverse list))
(block)
(kata))
(dolist (x list* kata)
(cond ((symbolp x)
(push (list x block) kata)
(setf block nil))
(t (push x block))))))

CL-USER> (kata ‘(a 1 2 3 b 4 5 c d 8 9 e))
((A (1 2 3)) (B (4 5)) (C NIL) (D (8 9)) (E NIL))

By: Anthony

Anthony — Sat, 25 Nov 2006 14:27:27 +0000

Hey!!!
Everybody..
Is there anybody that can give some tips in parogramming using scheme…
This is my subject this schoolyear..
Please!!!1

By: siktir a.q.

siktir a.q. — Thu, 16 Mar 2006 16:13:37 +0000

amınıza koyim sizin

By: Ian G

Ian G — Tue, 28 Feb 2006 14:36:07 +0000

Okay, here's a different take. Could be made shorter if you used let-values but this is the R5RS version.

(define (plist->alist lst)
  (define (reduce l)
    (if (null? l)
        (values () ())
        (let ((head (car l))
              (tail (cdr l)))
          (call-with-values
              (lambda () (reduce tail))
            (lambda (non-symbols tail)
              (if (symbol? head)
                  (values ()
                          (cons (list head non-symbols) tail))
                  (values (cons head non-symbols) tail)))))))
  (call-with-values (lambda () (reduce lst))
    (lambda (ignore result) result)))

By: Greg Buchholz

Greg Buchholz — Mon, 13 Feb 2006 20:57:54 +0000

The Haskell language list library has an interesting function “groupBy”with a nice concise definition. You’d use it like…

import Data.List


data Sym = A | B | C | D | E deriving Show

data Foo = S Sym | N Integer 
instance Show Foo where

    show (S x) = show x

    show (N x) = show x
main = print $

        map (\x -> (head x, tail x))

            (groupBy nums [ S A, N 1, N 2, N 3,

                            S B, N 4, N 5,

                            S C,

                            S D, N 8, N 9,

                            S E                 ])
nums (S _) (N _) = True  --A symbol followed by a number is good group

nums (N _) (N _) = True  --A number followed by a number is good group

nums _     _     = False --Anything else needs a new grouping

By: Kevin Greer

Kevin Greer — Mon, 13 Feb 2006 15:18:06 +0000

Here's my solution which is O(n) and doesn't use any built-in list processing functions like reverse, append, map, fold, etc. Just cons, car, and cdr.

(define (plist->alist l)
  (define (f l)
        (if (null? l)
           '(())
           (let* ((rest (f (cdr l)))
                  (cur  (cons (cons (car l) (car rest)) (cdr rest))))
                      (if (symbol? (car l)) (cons '() cur) cur))))
  (cdr (f l)))

By: Andi

Andi — Thu, 09 Feb 2006 20:51:33 +0000

relatively new to scheme, judging by some c.l.s submissions i am not thinking functional enough just yet:

(define (bucketize lis)
  (cond ((null? lis) '())
        ((not (symbol? (car lis))) (error "expected a symbol"))
        (else
         (let LOOP ((args '()) (lis2 (cdr lis)))
           (cond ((null? lis2) (list (list (car lis) (reverse args))))
                 ((symbol? (car lis2)) (cons (list (car lis) (reverse args)) (bucketize lis2)))
                 (else (LOOP (cons (car lis2) args) (cdr lis2))))))))

By: willyh

willyh — Tue, 07 Feb 2006 20:23:07 +0000

Okay, here's mine:

(define (segregate-list l)
  (let segregate ((key (car l))
                  (test-pred? number?)
                  (input-list (cdr l))
                  (key-list '())
                  (output-list '()))
    (if (null? input-list)
      (reverse (cons (cons key (list (reverse key-list))) output-list))
      (if (not (test-pred? (car input-list)))
          (segregate (car input-list)
                     test-pred?
                     (cdr input-list)
                     '()
                     (cons (cons key (list (reverse key-list)))
                           output-list))
          (segregate key
                     test-pred?
                     (cdr input-list)
                     (cons (car input-list) key-list)
                     output-list)))))