id int64 0 45.1k | file_name stringlengths 4 68 | file_path stringlengths 14 193 | content stringlengths 32 9.62M | size int64 32 9.62M | language stringclasses 1
value | extension stringclasses 6
values | total_lines int64 1 136k | avg_line_length float64 3 903k | max_line_length int64 3 4.51M | alphanum_fraction float64 0 1 | repo_name stringclasses 779
values | repo_stars int64 0 882 | repo_forks int64 0 108 | repo_open_issues int64 0 90 | repo_license stringclasses 8
values | repo_extraction_date stringclasses 146
values | sha stringlengths 64 64 | __index_level_0__ int64 0 45.1k | exdup_ids_cmlisp_stkv2 listlengths 1 47 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
16,822 | packs.lisp | oblivia-simplex_genlin/packs.lisp | (in-package :genlin)
;; =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
;; Pack operations
;; =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
;; a pack is a list of creatures
;; we'll start with a simple control structure: the car of the pack is
;; the delegator. It dele... | 3,951 | Common Lisp | .lisp | 91 | 36.846154 | 167 | 0.622848 | oblivia-simplex/genlin | 3 | 2 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | f6c7da87cdfd459a85a247fd6c906b83bd921d0c071cc6d955c62fa50cc7307c | 16,822 | [
-1
] |
16,823 | compile.lisp | oblivia-simplex_genlin/compile.lisp | (load "~/quicklisp/setup.lisp")
(ql:quickload :genlin)
(sb-ext:save-lisp-and-die "GENLIN" :executable t :toplevel #'genlin::main)
| 130 | Common Lisp | .lisp | 3 | 42.333333 | 74 | 0.732283 | oblivia-simplex/genlin | 3 | 2 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | ac2a073a49ca21ce70e36d30fd7f40a396151c6bf260e1dc5b9ae5668824243b | 16,823 | [
-1
] |
16,824 | scratch.lisp | oblivia-simplex_genlin/scratch.lisp |
;; bad code repetition here. once it's working, merge it with
;; the main evolve loop, and parameterize away the difference between
;; evolving hives and evolving individuals.
(defun evolve-hives (&key (hive-ring)
(h-rounds)
(h-smethod #'tournement!))
;; no real reason ... | 3,034 | Common Lisp | .lisp | 63 | 33.142857 | 88 | 0.471807 | oblivia-simplex/genlin | 3 | 2 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | a4bceeb7db66e18d8c26b3e3c7b91135359f3ac44a22ce2a149bed203ed86ae9 | 16,824 | [
-1
] |
16,825 | slomachine.lisp | oblivia-simplex_genlin/slomachine.lisp | (in-package :genlin)
;;; This copy only exists for the sake of carefree tinkering. Eventually,
;;; it will be merged with r-machine.lisp, the difference between the two
;;; coming down to a choice of parameters.
(defparameter *machine* :slomachine)
;;; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%... | 20,515 | Common Lisp | .lisp | 434 | 35.953917 | 84 | 0.519681 | oblivia-simplex/genlin | 3 | 2 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 587e411ab9c6450f2dfbc6afbb1f29bd5b9527712058b637bd398adec3c1dd26 | 16,825 | [
-1
] |
16,826 | auxiliary.lisp | oblivia-simplex_genlin/auxiliary.lisp | ;; =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
;; General Mathematical Helper Functions
;; =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
(in-package :genlin)
(defun avg (&rest args)
(divide (reduce #'+ args) (length args)))
(export 'reverse-hash-table)
(defun ... | 8,308 | Common Lisp | .lisp | 213 | 31.464789 | 100 | 0.514876 | oblivia-simplex/genlin | 3 | 2 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 75ee58b7406241b1d1ec252c90733a6f5accc5a9a8cfad022f56754f29fce4de | 16,826 | [
-1
] |
16,827 | genlin.lisp | oblivia-simplex_genlin/genlin.lisp | ;; =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
;; ___ ___ _ _ _ ___ _ _
;; / __| __| \| | | |_ _| \| |
;; | (_ | _|| .` | |__ | || .` |
;; \___|___|_|\_|____|___|_|\_| Linear Genetic Programming Engine
;;
;; =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
(... | 83,400 | Common Lisp | .lisp | 1,695 | 36.709735 | 156 | 0.522329 | oblivia-simplex/genlin | 3 | 2 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 5968f60a88b5c83bc4db6b11d75e6be882460b2ee7aacbeb8f1a284b259fdf60 | 16,827 | [
-1
] |
16,828 | stackmachine.lisp | oblivia-simplex_genlin/stackmachine.lisp | (in-package :genlin)
;;; This copy only exists for the sake of carefree tinkering. Eventually,
;;; it will be merged with r-machine.lisp, the difference between the two
;;; coming down to a choice of parameters.
(defparameter *machine* :stackmachine)
;;; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%... | 30,915 | Common Lisp | .lisp | 680 | 35.545588 | 99 | 0.508294 | oblivia-simplex/genlin | 3 | 2 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 396438bbd3df6b58fbf9d5f1251bacb5094cf856f3cd12011c84e1590f411413 | 16,828 | [
-1
] |
16,829 | r-machine.lisp | oblivia-simplex_genlin/r-machine.lisp | (in-package :genlin)
(defparameter *machine* :r-machine)
;; =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
;; INSTRUCTION FIELDS
;; =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
;; --- Adjust these 3 parameters to tweak the instruction set. ... | 14,732 | Common Lisp | .lisp | 311 | 39.88746 | 84 | 0.566989 | oblivia-simplex/genlin | 3 | 2 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 6273cca84a503eda7d5748fb129b3868c13b0a657288be6b603e7e06eafb30d7 | 16,829 | [
-1
] |
16,830 | params.lisp | oblivia-simplex_genlin/params.lisp | (in-package #:genlin)
;; =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
;; types and structs
;; =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
(export 'creature)
(defstruct creature id fit cm seq eff gen mut typ home parents pack)
(export 'island-id)
(export 'islan... | 14,876 | Common Lisp | .lisp | 336 | 40.702381 | 116 | 0.674453 | oblivia-simplex/genlin | 3 | 2 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 7bb087238a30dd9526f5d414d18fe1cae48e20bcb8b53e3afa5e73fccc5c546f | 16,830 | [
-1
] |
16,831 | rcompile.lisp | oblivia-simplex_genlin/rcompile.lisp | (load "genlin.lisp")
(in-package :genlin)
(setf *machine* :r-machine)
(load-other-files)
(sb-ext:save-lisp-and-die "R-GENLIN" :executable t :toplevel #'main)
| 158 | Common Lisp | .lisp | 5 | 30.6 | 68 | 0.72549 | oblivia-simplex/genlin | 3 | 2 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 50b7b2159d191d464f771472df704b8c0aa253d9ba8749eb47ba8f52a89c2a74 | 16,831 | [
-1
] |
16,832 | tictactoe.lisp | oblivia-simplex_genlin/tictactoe.lisp | ;; =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
;; Data reading functions
;; =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
;; (defpackage :genlin
;; (:use :common-lisp))
(in-package #:genlin)
(defparameter *01vs+-* t)
;; -- Tic-Tac-Toe Environment)
(let* ((.t... | 10,483 | Common Lisp | .lisp | 218 | 37.848624 | 201 | 0.460886 | oblivia-simplex/genlin | 3 | 2 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 6cfac403dcd6827e3fff8c9f9fe00e99930914e33b9144c33b99c07530cce720 | 16,832 | [
-1
] |
16,833 | altcrossover.lisp | oblivia-simplex_genlin/altcrossover.lisp | ;; This buffer is for notes you don't want to save, and for Lisp evaluation.
;; If you want to create a file, visit that file with C-x C-f,
;; then enter the text in that file's own buffer.
(defun shufflefuck (p0 p1)
(declare (type creature p0 p1))
(declare (optimize (speed 1)))
(let* (;;(lp0 (length (creature-... | 2,062 | Common Lisp | .lisp | 43 | 39.093023 | 85 | 0.55 | oblivia-simplex/genlin | 3 | 2 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 55fca451fd3dc210f33d44b74d2c598a738e6a17ed9be7b3bf46cc76d71598f5 | 16,833 | [
-1
] |
16,834 | datafiler.lisp | oblivia-simplex_genlin/datafiler.lisp | ;; =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
;; Data reading functions
;; =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
;;(defpackage :genlin
;; (:use :common-lisp))
(in-package #:genlin)
;; moved here from params. may cause bug.
(defparameter =label-scanner=... | 12,317 | Common Lisp | .lisp | 265 | 32.667925 | 114 | 0.496909 | oblivia-simplex/genlin | 3 | 2 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | f3f4f7756de74962ed12dde4bf6f1aa5f00cebd5c27a57b26c713bcfc3ccbc16 | 16,834 | [
-1
] |
16,835 | frontend.lisp | oblivia-simplex_genlin/frontend.lisp | (load #p"~/Projects/genlin/package.lisp")
;; (defpackage :genlin
;; (:use :common-lisp))
(in-package #:genlin)
;;; =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
;;; Linear Genetic Algorithm
;;; =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
(defparameter *project-... | 14,455 | Common Lisp | .lisp | 317 | 34.832808 | 90 | 0.534392 | oblivia-simplex/genlin | 3 | 2 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | f6f5762e3ce0e604be3afce3e76ca4ba241c05ee5699403b9ea3865b6fdae213 | 16,835 | [
-1
] |
16,836 | hello.lisp | oblivia-simplex_genlin/genetic-hello/hello.lisp | (defpackage :genetic.hello
(:use :common-lisp))
(in-package :genetic.hello)
;(defparameter *target* "Genetic Algorithm")
;;(defparameter *target* "You do look, my son, in a moved sort, As if you were dismay'd: be cheerful, sir. Our revels now are ended. These our actors, As I foretold you, were all spirits and Are ... | 5,191 | Common Lisp | .lisp | 103 | 44.912621 | 766 | 0.636885 | oblivia-simplex/genlin | 3 | 2 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 9d658c002576c2d15ea41f67bfd23193252feb1d33721fcb470e030e1fc5cfd3 | 16,836 | [
-1
] |
16,838 | compile.lisp | oblivia-simplex_genlin/genetic-hello/compile.lisp | (load "hello.lisp")
(in-package :genetic.hello)
(sb-ext:save-lisp-and-die "hello" :executable t :toplevel #'main)
| 115 | Common Lisp | .lisp | 3 | 37 | 65 | 0.72973 | oblivia-simplex/genlin | 3 | 2 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 740fdd389c4642021e527e3ef7dce5cc29eaecd977242ce488edaaddabc7c572 | 16,838 | [
-1
] |
16,839 | genlin.asd | oblivia-simplex_genlin/genlin.asd | ;;;; genlin.asd
(asdf:defsystem #:genlin
:description "A linear genetic programming engine"
:author "Olivia Lucca Fraser <lucca.fraser@gmail.com>"
:license "GNU GPL"
;; :depends-on (#:sb-thread)
:serial t
:components ((:file "package")
(:file "auxiliary")
(:file... | 545 | Common Lisp | .asd | 16 | 24.6875 | 56 | 0.524462 | oblivia-simplex/genlin | 3 | 2 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | a3fdb37274387a90d5ea94d0c819ebae0bb5ccb5e7be46ab841130c639c9e04a | 16,839 | [
-1
] |
16,848 | Makefile | oblivia-simplex_genlin/Makefile | genlin: compile.lisp genlin.lisp auxiliary.lisp tictactoe.lisp stackmachine.lisp params.lisp frontend.lisp
sbcl --dynamic-space-size 2048 --script compile.lisp
# testing
# testing
data: datasets.tgz
tar xzvf datasets.tgz
all: genlin data
clean:
tar czvf datasets.tgz datasets/
rm -rf datasets GENLIN
| 307 | Common Lisp | .l | 10 | 29 | 106 | 0.816949 | oblivia-simplex/genlin | 3 | 2 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 6c591299c980838e7c7bbeeefe79a73dc80775e1faecb9d5198aaafe68bbe243 | 16,848 | [
-1
] |
16,849 | trials.sh | oblivia-simplex_genlin/trials.sh | #! /bin/bash
./GENLIN --parallel t \
--packs nil \
--opcode-bits 3 \
--dataset :thyroid \
--data-path \"./datasets/thyroid/ann-train.lbl.csv\" \
--testing-data-path \"./datasets/thyroid/ann-test.lbl.csv\" \
--sex nil \
--mutation-rate 1 \
--select... | 7,239 | Common Lisp | .l | 208 | 25.326923 | 70 | 0.529479 | oblivia-simplex/genlin | 3 | 2 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | bb76c466167093598d1f0bf2b2926e3040baa83d0600f21c56505661d5b58f7d | 16,849 | [
-1
] |
16,879 | test-profiler.lsp | clausb_lisp-profiler/test-profiler.lsp | ;;-*-Lisp-*-
;; Test code for ridiculously trivial profiler for Lisp code
;; See http://www.clausbrod.de/Blog/DefinePrivatePublic20160308LispProfiler
;; Original author: Claus Brod
;; http://www.clausbrod.de
;;
;; For licensing details, see the LICENSE file.
;; For documentation, see README.md.
(in-... | 803 | Common Lisp | .l | 19 | 40.631579 | 103 | 0.705806 | clausb/lisp-profiler | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | dd763b0f68388d0631c88a2d1069e45042b19c6448a6f5aa6986d42f6708a204 | 16,879 | [
-1
] |
16,880 | lisp-profiler.lsp | clausb_lisp-profiler/lisp-profiler.lsp | ;;-*-Lisp-*-
;; Ridiculously trivial profiler for Lisp code
;; See http://www.clausbrod.de/Blog/DefinePrivatePublic20160308LispProfiler
;;
;; Original author: Claus Brod
;; http://www.clausbrod.de
;;
;; For licensing details, see the LICENSE file.
;; For documentation, see README.md.
;;
(in-package :p... | 5,078 | Common Lisp | .l | 117 | 38.931624 | 165 | 0.713905 | clausb/lisp-profiler | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | a9967488eff831a4c8a73e57ca2e405743c71943af4e898ca527517eebedbe66 | 16,880 | [
-1
] |
16,881 | lisp-profiler-ui.lsp | clausb_lisp-profiler/lisp-profiler-ui.lsp | ;;-*-Lisp-*-
;; UI dialog for ridiculously trivial Lisp profiler
;; See http://www.clausbrod.de/Blog/DefinePrivatePublic20160308LispProfiler
;; Original author: Claus Brod
;; http://www.clausbrod.de
;;
;; For licensing details, see the LICENSE file.
;; For documentation, see README.md.
(in-package :... | 2,177 | Common Lisp | .l | 59 | 32.474576 | 100 | 0.713739 | clausb/lisp-profiler | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | c248485da10216b321a8bd16fc336c401d5781cf8287d19a7b95cf231d512292 | 16,881 | [
-1
] |
16,899 | delta.package.lisp | epipping_delta-lisp/delta.package.lisp | ;; -*- mode:common-lisp; indent-tabs-mode: nil -*-
(defpackage #:delta
(:export #:delta-file)
(:use #:cl)
(:use #:let-plus))
| 132 | Common Lisp | .lisp | 5 | 24 | 50 | 0.603175 | epipping/delta-lisp | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 8fe47931ac6236a648a8b003aa45e8cb8ddddf6bab2aae161c8d7e1679bf85c1 | 16,899 | [
-1
] |
16,900 | delta-tests.package.lisp | epipping_delta-lisp/delta-tests.package.lisp | ;; -*- mode:common-lisp; indent-tabs-mode: nil -*-
(defpackage #:delta-tests
(:use #:cl
#:5am))
| 107 | Common Lisp | .lisp | 4 | 23 | 50 | 0.578431 | epipping/delta-lisp | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 786e4b9adca836cf4efaa7a84c4cee1983da78b04f3ebbd918b27c7ba85e3912 | 16,900 | [
-1
] |
16,901 | delta-standalone.package.lisp | epipping_delta-lisp/delta-standalone.package.lisp | ;; -*- mode:common-lisp; indent-tabs-mode: nil -*-
(defpackage #:delta-standalone
(:export #:main)
(:use #:cl)
(:use #:let-plus))
| 137 | Common Lisp | .lisp | 5 | 25 | 50 | 0.618321 | epipping/delta-lisp | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 9be25f031048b264c698e419db183637975513a20e9a6398c6a022f687a0764c | 16,901 | [
-1
] |
16,902 | utilities.lisp | epipping_delta-lisp/utilities.lisp | ;; -*- mode:common-lisp; indent-tabs-mode: nil -*-
(in-package #:delta)
(defun compute-break (length part numparts)
"Compute mark at which chunk #`part` begins when a list of length
`length` is divided into `numparts`-many chunks of (roughly) equal
size."
(floor (* part length) numparts))
(defun exclude-range (f... | 723 | Common Lisp | .lisp | 18 | 37.111111 | 71 | 0.691429 | epipping/delta-lisp | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | cbfd2f0224c7cd35eda0904a19abad66bb3ebfd1639b0908c04fd9fce450d780 | 16,902 | [
-1
] |
16,903 | delta-tests.lisp | epipping_delta-lisp/delta-tests.lisp | ;; -*- mode:common-lisp; indent-tabs-mode: nil -*-
(in-package #:delta-tests)
(def-suite delta-utility-tests
:description "Test utilities contained within delta.")
(in-suite delta-utility-tests)
(test compute-break
"Test the compute-break function."
(is (= 0 (delta::compute-break 10 0 2)))
(is... | 929 | Common Lisp | .lisp | 21 | 39.047619 | 70 | 0.599778 | epipping/delta-lisp | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 60713419d14aaabc0339540764c6353bd506ba437e6ee0c4d365793a683fe230 | 16,903 | [
-1
] |
16,904 | delta.lisp | epipping_delta-lisp/delta.lisp | ;; -*- mode:common-lisp; indent-tabs-mode: nil -*-
(in-package #:delta)
(defvar *max-processes*)
(defvar *script-name*)
(defvar *minimal-output-name* "output-minimal")
(defvar *file-contents*)
(defvar *suffix*)
(defvar *quiet*)
(defvar *show-stdout*)
(defvar *show-stderr*)
(alexandria:define-constant +sleep-between-... | 7,728 | Common Lisp | .lisp | 164 | 36.756098 | 77 | 0.606362 | epipping/delta-lisp | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 8fc5c04ac1dd55988d30d8abf7b4e818962d62eb832bc6236d2ab3017ce8e21a | 16,904 | [
-1
] |
16,905 | test.lisp | epipping_delta-lisp/mk/test.lisp | (load "mk/path.lisp")
(asdf:operate 'asdf:load-op :delta-tests)
(5am:run 'delta-tests::delta-utility-tests)
(write-line "")
(quit)
| 134 | Common Lisp | .lisp | 5 | 25.2 | 43 | 0.722222 | epipping/delta-lisp | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 0b7d88998d583b02171871e8f6d4c7bbf54bf29f665eae203871f14850501dea | 16,905 | [
-1
] |
16,906 | delta.asd | epipping_delta-lisp/delta.asd | (asdf:defsystem #:delta
:serial t
:depends-on (#:alexandria #:let-plus)
:components ((:file "delta.package")
(:file "utilities" :depends-on ("delta.package"))
(:file "delta" :depends-on ("delta.package"))))
| 243 | Common Lisp | .asd | 6 | 33.5 | 64 | 0.594937 | epipping/delta-lisp | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | b236aab4c45518b9b7a5745886396648caaf35347f9a77d5a5e606343c9a53d4 | 16,906 | [
-1
] |
16,907 | delta-tests.asd | epipping_delta-lisp/delta-tests.asd | (asdf:defsystem #:delta-tests
:serial t
:depends-on (#:delta #:FiveAM)
:components ((:file "delta-tests.package")
(:file "delta-tests" :depends-on ("delta-tests.package"))))
| 195 | Common Lisp | .asd | 5 | 33.8 | 74 | 0.636842 | epipping/delta-lisp | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | dd0a48396538acf580786e1d36878c65c3c0e417fc26339dcc9d620f432e40db | 16,907 | [
-1
] |
16,908 | delta-standalone.asd | epipping_delta-lisp/delta-standalone.asd | (asdf:defsystem #:delta-standalone
:serial t
:depends-on (#:alexandria #:delta #:getopt)
:components ((:file "delta-standalone.package")
(:file "delta-standalone" :depends-on ("delta-standalone.package")))
:entry-point "delta-standalone:main"
:build-operation program-op
:build-pathname "delta... | 334 | Common Lisp | .asd | 8 | 37.375 | 83 | 0.708589 | epipping/delta-lisp | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 715c8ea506066fe8ea3581f6456311594d9fa17af621d0296638790e65de83e5 | 16,908 | [
-1
] |
16,919 | secondorderassemblertest-57319f.ii | epipping_delta-lisp/t/clang-28087/secondorderassemblertest-57319f.ii | namespace std {
typedef long unsigned int size_t;
template <typename> class allocator;
template <typename _Tp, _Tp __v> struct integral_constant {
static constexpr _Tp value = __v;
typedef _Tp value_type;
typedef integral_constant<_Tp, __v> type;
constexpr operator value_type() const {}
};
typed... | 23,771 | Common Lisp | .l | 570 | 37.2 | 80 | 0.701263 | epipping/delta-lisp | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | eea7b4edd85b114641215375fa6bfda83830435c208335ab69f78cf155232ba9 | 16,919 | [
-1
] |
16,935 | robit.lisp | karason_lisp-robit/robit.lisp | ;;;; robit.lisp— an internet relay chat automaton defined in common lisp.
;;; Copyright (C) 2013 Chris Wallace and Ryan Karason
;;;
;;; This program is free software: you can redistribute it and/or modify
;;; it under the terms of the GNU General Public License as published by
;;; the Free Software Foundation, either ... | 6,705 | Common Lisp | .lisp | 185 | 27.940541 | 105 | 0.577719 | karason/lisp-robit | 3 | 0 | 4 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | a7cba8a842ad9a6772d5064da64b15e111fa133d3127efb7fe46b4070571abbe | 16,935 | [
-1
] |
16,936 | eval-me.lisp | karason_lisp-robit/eval-me.lisp | ;EVAL-ME.LISP: create configuration file for ROBIT.LISP
(princ "Path of robit? ")
(defparameter *robit-path*
(read-line))
;stream for configuration file
(defparameter stream
(open
(concatenate 'string
*robit-path*
"/.robitrc")
:direction :output
:if-exists :ne... | 3,925 | Common Lisp | .lisp | 123 | 27.260163 | 78 | 0.638742 | karason/lisp-robit | 3 | 0 | 4 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | fc8882dc33a4614cd0816a14959cd1dd411a095a763eaf0ff12c2f75b968d983 | 16,936 | [
-1
] |
16,937 | safe-eval.lisp | karason_lisp-robit/safe-eval.lisp | (defparameter arithm
(list '+ '- '* '/))
(defun is-safe? (sexp safe-commands)
(cond
((eq sexp nil)
T)
((atom sexp)
(member sexp safe-commands))
((atom (car sexp))
(and (member (car sexp) safe-commands)
(is-safe? (cdr sexp) safe-commands)) )
(T
(and (is-safe? (car sexp) safe-commands)
(... | 362 | Common Lisp | .lisp | 14 | 22.214286 | 44 | 0.618768 | karason/lisp-robit | 3 | 0 | 4 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 3abb264bef49da4ad1744a9287881df8cf1b3f5924873b82694a8584b99b0f60 | 16,937 | [
-1
] |
16,938 | shelly.lisp | karason_lisp-robit/modules/shelly.lisp | ;;;; shelly.lisp
(defun stream-to-list (a-stream)
(let
((line
(read-line a-stream nil)))
(cond
((eq line 'nil)
'())
(t
(cons line (stream-to-list a-stream))))))
(defun $ (command)
(stream-to-list
(run-shell-command com... | 344 | Common Lisp | .lisp | 13 | 17.615385 | 57 | 0.480243 | karason/lisp-robit | 3 | 0 | 4 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | e19d39b846e5dcdd2df0036b2897af7561965230c56f84833757777d0a5d1e58 | 16,938 | [
-1
] |
16,939 | dice.lisp | karason_lisp-robit/modules/dice.lisp | ;;;; dice.lisp
(defparameter ⚀ '1)
(defparameter ⚁ '2)
(defparameter ⚂ '3)
(defparameter ⚃ '4)
(defparameter ⚄ '5)
(defparameter ⚅ '6)
(defun dieify (numeric)
(cond
((eq numeric '1) '⚀)
((eq numeric '2) '⚁)
((eq numeric '3) '⚂)
((eq numeric '4) '⚃)
((eq numeric '5) '⚄)
... | 1,139 | Common Lisp | .lisp | 39 | 21.897436 | 84 | 0.492049 | karason/lisp-robit | 3 | 0 | 4 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | bd9931b925c014ac9ae3bd1cc2155d20a850842c0f15afde3f5c3fc8c92841a5 | 16,939 | [
-1
] |
16,940 | elements.lisp | karason_lisp-robit/modules/elements.lisp | ;;;; elements.lisp
;;; *elements*— atomic-number, atomic-symbol, atomic-name, atomic-weight, atomic-density, atomic-radius
(defparameter *elements*
'((1 '(H Hydrogen 1.00794 0.0000899 53))
(2 '(He Helium 4.002602 0.0001785 31))
(3 '(Li Lithium 6.941 0.535 167))
(4 '(Be Beryllium 9.012182 1.848 ... | 8,260 | Common Lisp | .lisp | 188 | 36.595745 | 106 | 0.602857 | karason/lisp-robit | 3 | 0 | 4 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 38427d9345a49a663bc14e922834bf3fbde7679f054505c66c06c7328f08614f | 16,940 | [
-1
] |
16,941 | misc.lisp | karason_lisp-robit/modules/misc.lisp | ;;;; misc.lisp
(defun robit ()
"https://github.com/karason/lisp-robit")
(defun beep () 'boop)
(defun boop () 'beep)
(defun help (&optional query)
(cond
((eq query 'nil)
"http://www.lispworks.com/documentation/HyperSpec/Front/index.htm")
(t
(concatenate 'string "http:/... | 371 | Common Lisp | .lisp | 11 | 28 | 90 | 0.613445 | karason/lisp-robit | 3 | 0 | 4 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 58dff325dec877eb9bcd75571777b9bc2c9e20128c32eb30780b292d4ee11775 | 16,941 | [
-1
] |
16,945 | robit.manual | karason_lisp-robit/robit.manual | #manual for robit.lisp
robit.lisp is an internet relay chat automaton defined in common lisp
#prerequisites for execution
common lisp interpreter (CLISP is assumed)
quicklisp system
cl-irc library
#to execute robit
if .robitrc does not exist,
evaluate eval-me.lisp #clisp eval-me.lisp
eval... | 626 | Common Lisp | .l | 18 | 29.944444 | 71 | 0.723967 | karason/lisp-robit | 3 | 0 | 4 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 7814824b399cf9500962240eff444fa42a0232e13da22d930a493b13fb1482ac | 16,945 | [
-1
] |
16,947 | .logrc | karason_lisp-robit/logs/.logrc | "clear all syntax
syntax clear
"time
syntax match Identifier /[0-9][0-9]:[0-9][0-9]:[0-9][0-9]/
"channel
syntax region Comment start=/#/ end=/ / oneline
"user
syntax region Statement start=/</ end=/>/ oneline
"hyperlink
syntax region Type start=/www./ end=/[\n\ ]/
syntax region Type start=/http:./ end=/[\n\ ]/
syn... | 463 | Common Lisp | .l | 16 | 27.5 | 58 | 0.693878 | karason/lisp-robit | 3 | 0 | 4 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 351d30c5c2af1efdc0e708f32689a597c4844098ea69ef31c99712b59f6ac13c | 16,947 | [
-1
] |
16,967 | parametryk.lsp | kmartenczuk_AutoLISP/Parametryk_zlacze_postaciowe_wieloboczne_trojkatne/param/parametryk.lsp | ;;;;;;;;; ZLACZE WIELOBOCZNE TRÓJKATNE ;;;;;;;;;
;Kamil Martenczuk Autodesk Authorized Developer;
;;;;;;;;;;;;;; ADN ID DEPL2710 ;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;; 05/2020 ;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;Przeliczenia katów
(defun kat (w) (* pi (/ w 180.0)))
(defun kat... | 4,985 | Common Lisp | .l | 113 | 40.19469 | 124 | 0.541735 | kmartenczuk/AutoLISP | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | b33838c1b42ff8311a13680c5c6482b7776458e3d6a12c6d4528dd05bccd4a9a | 16,967 | [
-1
] |
16,968 | parametryk_zlacza_dane.txt | kmartenczuk_AutoLISP/Parametryk_zlacze_postaciowe_wieloboczne_trojkatne/tablice/parametryk_zlacza_dane.txt | 30 32.0 28.0 1.00 0.6 150
35 37.5 32.5 1.25 0.6 150
40 42.8 37.2 1.40 0.6 150
45 48.2 41.8 1.60 0.6 150
50 53.6 46.4 1.80 0.6 150
55 59.0 51.0 2.00 0.6 150
60 64.5 55.5 2.25 0.6 150
65 69.9 60.1 2.45 0.6 150
70 75.6 64.4 2.80 0.6 150
75 81.3 68.7 3.15 0.6 150 | 269 | Common Lisp | .l | 10 | 25 | 27 | 0.615385 | kmartenczuk/AutoLISP | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | f71bf08c930cb7b1b10b7241f0ff70189f811c711b8d9f6652fca5a1a4abcd0c | 16,968 | [
-1
] |
16,984 | get_circles_together_and_color_them.lsp | CiganOliviu_AutoLISP-autocad/get_circles_together_and_color_them.lsp | (defun get_average(sum index)
(setq result (/ sum index))
(setq result result)
)
(defun set_new_center(entities center)
(setq index 0)
(repeat (sslength circles)
(setq circle (entget (ssname circles index)))
(setq circle (subst (cons 10 center) (assoc 10 circle) circle))
... | 1,194 | Common Lisp | .cl | 39 | 24.076923 | 73 | 0.601232 | CiganOliviu/AutoLISP-autocad | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 1a2eabd3f84d878ae3a4fe7e43ed03eebf3a3d212ed28b36f207ac7adca3aa1e | 16,984 | [
-1
] |
16,985 | draw_circle_based_on_conditions.LSP | CiganOliviu_AutoLISP-autocad/draw_circle_based_on_conditions.LSP | (defun projdist (p0 p1)
(list (abs (- (car p0) (car p1)))
(abs (- (cadr p0) (cadr p1)))
)
)
(defun C:CIRCLEC (/ radius start_rectangle_point)
(setq start_rectangle_point (getpoint "Pick first point of rectangle"))
(setq second_rectangle_point (getcorner start_rectangle_point "Pick second point of rec... | 816 | Common Lisp | .cl | 20 | 36.55 | 99 | 0.691421 | CiganOliviu/AutoLISP-autocad | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 2c7e8d530e9a90b5671b6bb4b407a16bd98ac933536a53d3a84766c87c087324 | 16,985 | [
-1
] |
16,986 | get_circles_together.lsp | CiganOliviu_AutoLISP-autocad/get_circles_together.lsp |
(defun get_average(sum index)
(setq result (/ sum index))
(setq result result)
)
(defun set_new_center(entities center)
(setq index 0)
(repeat (sslength circles)
(setq circle (entget (ssname circles index)))
(setq circle (subst (cons 10 newCenter) (assoc 10 circle) circle))
(entmod circle)... | 993 | Common Lisp | .cl | 35 | 23.885714 | 70 | 0.657297 | CiganOliviu/AutoLISP-autocad | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 75d3e16df1449d26cd3a23f3ae2be4f76bd281110af5c3c49fc601623a82903c | 16,986 | [
-1
] |
16,988 | simple_sentence.lsp | CiganOliviu_AutoLISP-autocad/simple_sentence.lsp | (defun first_sentence (a b)
(setq result (+ 22 (* a (+ 13 b))))
)
(defun second_sentence (a b c d)
(setq result (+ (* a b) (* c d)))
) | 139 | Common Lisp | .l | 6 | 21.5 | 37 | 0.548872 | CiganOliviu/AutoLISP-autocad | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 0701ec1d6d0edef41e9c1420a1418efdec0c95b9655ff394ace44199568790a9 | 16,988 | [
-1
] |
16,990 | PD_SEARCH.lsp | CiganOliviu_AutoLISP-autocad/PD_SEARCH.lsp | (defun C:PD_ADDENTRY ( / fname lname age entry)
(initget 1)
(setq fname (getstring "\nEnter person's first name: "))
(initget 1)
(setq lname (getstring "\nEnter person's last name: "))
(initget 7)
(setq age (getint "\nEnter person's age: "))
(setq entry (list (cons 'FN fname) (cons 'LN lname) (cons 'A... | 1,424 | Common Lisp | .l | 52 | 22.634615 | 70 | 0.6 | CiganOliviu/AutoLISP-autocad | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | c567eab6549402294629868a63cc5deb721a97cdb7fdf248b25e8d9de6c6ac58 | 16,990 | [
-1
] |
16,991 | draw_david_star.lsp | CiganOliviu_AutoLISP-autocad/draw_david_star.lsp | (defun C:DRAW_DAVID_STAR (/ star_center star_radius)
(setq star_center (getpoint "\nChoose star center:"))
(setq star_radius (getdist star_center "\nChoose star radius:"))
(command "polygon" 3 star_center "inscribed" star_radius)
(command "rotate" (entlast) "" star_center "180")
(command "polygon" 3 star... | 354 | Common Lisp | .l | 7 | 47.571429 | 65 | 0.726471 | CiganOliviu/AutoLISP-autocad | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 07422ba6daa7c1721765d6d1a4477e49eadf3f669948f6627c5213912d2a9c63 | 16,991 | [
-1
] |
16,992 | simple_formula.lsp | CiganOliviu_AutoLISP-autocad/simple_formula.lsp | (defun get_sum(x)
(setq end_point 20)
(setq index 2)
(setq result 0)
(while (<= index end_point)
(if (= (rem index 2) 0)
(setq result (+ result (* x index)))
)
(if (= (rem index 2) 1)
(setq result (+ result (+ x index)))
)
(setq index (+ 1 index))
)
(setq result r... | 328 | Common Lisp | .l | 15 | 17.2 | 42 | 0.539474 | CiganOliviu/AutoLISP-autocad | 3 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | fc306c22dbfc6611ce11620ea1dde00cfbe2759e8451d752508a4e8facc6601a | 16,992 | [
-1
] |
17,015 | ex-08-41.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-41.lisp | ; file: ex-08-41.lisp
; author: Jon David
; date: Wednesday, September 24, 2014
; description:
; exercise 8.41 - Write a function SUM-TREE that returns the sum of
; all the numbers appearing in a tree. Nonnumbers should be
; ignored. (SUM-TREE '((3 BEARS) (3 BOWLS) 1 (GIRL))) should return
; seven.
;
(defun s... | 425 | Common Lisp | .lisp | 14 | 28.571429 | 69 | 0.652068 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | e07b777bc8c290f605b99e6e30dfa83444b60bcf56f5ca6908a8d72d6b42737d | 17,015 | [
-1
] |
17,016 | ex-08-56.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-56.lisp | ; file: ex-08-56.lisp
; author: Jon David
; date: Monday, September 29, 2014
; description:
; exercise 8.56 - Write EVERY-OTHER, a recursive function that
; returns every other element of a list-the first, third, fifth,
; and so on. (EVERY-OTHER '(A B C D E F G)) should return (A C E G).
; (EVERY-OTHER '(I CAME... | 652 | Common Lisp | .lisp | 16 | 38.3125 | 70 | 0.682035 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 7beeb3cf4b6cc771ce1336b4d30936391b49f634df00fdd2f24804fe9d539540 | 17,016 | [
-1
] |
17,017 | ex-08-59.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-59.lisp | ; file: ex-08-59.lisp
; author: Jon David
; date: Monday, September 29, 2014
; description:
; exercise 8.59 - Here is another definition of the factorial
; function:
; Factorial(0) = 1
; Factorial(N) = Factorial(N+1) / (N+1)
;
; Verify that these equations are true. Is the definition recursive?
; Writ... | 1,114 | Common Lisp | .lisp | 28 | 38.642857 | 70 | 0.675576 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | e32e02dc25199ea4174ba9629a90a543edb4d882d01511c43364f23659bcf19b | 17,017 | [
-1
] |
17,018 | ex-08-22.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-22.lisp | ; file: ex-08-22.lisp
; author: Jon David
; date: Sunday, August 24, 2014
; description:
; exercise 8.22 - Write a recursive function ALL-EQUAL that returns
; T if the first element of a list is equal to the second, the
; second is equal to the third, the third is equal to the fourth,
; and so on. (ALL-EQUAL '(... | 673 | Common Lisp | .lisp | 15 | 43.466667 | 70 | 0.697108 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 15d8e3cea1fde0059dd5339a63cd8a50a2abba743a29a93eae533cf1f1f618df | 17,018 | [
-1
] |
17,019 | ex-08-40.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-40.lisp | ; file: ex-08-40.lisp
; author: Jon David
; date: Wednesday, September 24, 2014
; description:
; exercise 8.40 - Write COUNT-CONS, a function that returns the
; number of cons cells in a tree. (COUNT-CONS '(FOOD)) should
; return one. (COUNT-CONS '(FOO BAR)) should return two.
; (COUNT-CONS '((FOO))) should al... | 582 | Common Lisp | .lisp | 19 | 28.736842 | 65 | 0.646536 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 996530d15983411d4c3c28d4b31205a71e7a94ced7894b918e3c966f2ecec317 | 17,019 | [
-1
] |
17,020 | ex-08-52.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-52.lisp | ; file: ex-08-52.lisp
; author: Jon David
; date: Sunday, September 28, 2014
; description:
; exercise 8.52 - Write MY-UNION, a recursive version of UNION.
;
; Note:
; the book's solution is more efficient. It begins the union set
; with all of the elements in X and then for each element in Y
; not in X, it app... | 940 | Common Lisp | .lisp | 28 | 31.785714 | 72 | 0.612155 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 8d07bbb7e81b970f2d716bee5b63845ed9b5336fb3071dcf25b9fc903f0cf496 | 17,020 | [
-1
] |
17,021 | ex-08-64.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-64.lisp | ; file: ex-08-64.lisp
; author: Jon David
; date: Monday, October 21, 2014
; description:
; exercise 8.64 - Write a TREE-FIND-IF operator that returns the
; first non-NIL atom of a tree that satisfies a predicate.
; (TREE-FIND-IF #'ODDP '((2 4) (5 6) 7)) should return 5.
(defun tree-find-if (fn x)
(cond ((null... | 587 | Common Lisp | .lisp | 18 | 30.166667 | 66 | 0.622575 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | ff7c3edd9fbb2fdb77ba2e35a4227a226c3a3b02831bf3deff9d1f9fa7ad95f5 | 17,021 | [
-1
] |
17,022 | ex-08-09.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-09.lisp | ; file: ex-08-09.lisp
; author: Jon David
; date: Monday, August 18, 2014
; description:
; exercise 8.9 - Write a recursive version of NTH. Call it REC-NTH.
(defun rec-nth (count list)
(cond ((zerop count) (car list))
(t (rec-nth (- count 1) (cdr list)))))
| 265 | Common Lisp | .lisp | 8 | 31.375 | 69 | 0.673228 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | c4a8dfd54120e5e7ef9af9400f1bb3e4824407bb9977bcb41d9acdf116497c96 | 17,022 | [
-1
] |
17,023 | ex-08-43.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-43.lisp | ; file: ex-08-43.lisp
; author: Jon David
; date: Wednesday, September 24, 2014
; description:
; exercise 8.43 - Write FLATTEN, a function that returns all the
; elements of an arbitrarily nested list in a single-level list.
; (FLATTEN '((A B (R)) A C (A D ((A (B)) R) A))) should return
; (A B R A C A D A B R A... | 717 | Common Lisp | .lisp | 19 | 35.894737 | 68 | 0.653295 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 8df39213dce6e48cc34e60eee7bf089b06a2ddc64cf49cce5fd6c4058b78aebb | 17,023 | [
-1
] |
17,024 | ex-08-24.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-24.lisp | ; file: ex-08-24.lisp
; author: Jon David
; date: Sunday, August 24, 2014
; description:
; exercise 8.24 - Write COUNT-DOWN, a function that counts down from
; n using list-consing recursion. (COUNT-DOWN 5) should produce the
; list (5 4 3 2 1).
(defun count-down (n)
(cond ((zerop n) nil)
(t (cons n (count-do... | 336 | Common Lisp | .lisp | 10 | 32.2 | 70 | 0.673846 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | e7ebc79ec22ed99cd66e139ec74d1fbcbc981286bbc83491fdf1bd655bacfb66 | 17,024 | [
-1
] |
17,025 | ex-08-53.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-53.lisp | ; file: ex-08-53.lisp
; author: Jon David
; date: Sunday, September 28, 2014
; description:
; exercise 8.53 - Write LARGEST-EVEN, a recursive function that
; returns the largest even number in a list of nonnegative integers.
; (LARGEST-EVEN '(5 2 4 3)) should return four. (LARGEST-EVEN NIL)
; should return zero... | 661 | Common Lisp | .lisp | 16 | 39.3125 | 70 | 0.720565 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 918f2933c9caf15fdee727ee2ad26580c052c77293120f990f2262cb0f6c50d7 | 17,025 | [
-1
] |
17,026 | ex-08-50.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-50.lisp | ; file: ex-08-50.lisp
; author: Jon David
; date: Sunday, September 28, 2014
; description:
; exercise 8.50 - Write SUBLISTS, a function that returns the
; successive sublists of a list. (SUBLISTS '(FEE FIE FOE)) should
; return ((FEE FIE FOE) (FIE FOE) (FOE)).
(defun sublists (list)
(cond ((null list) nil)
(... | 370 | Common Lisp | .lisp | 10 | 35.2 | 67 | 0.684507 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | f0d8df8b94fb25dfbafbcd4b114ca4d6993de2ed25025c34cecd6386c25d9eae | 17,026 | [
-1
] |
17,027 | ex-08-51.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-51.lisp | ; file: ex-08-51.lisp
; author: Jon David
; date: Sunday, September 28, 2014
; description:
; exercise 8.51 - The simplest way to write MY-REVERSE, a recursive
; version of REVERSE, is with a helping function plus a recursive
; function of two inputs. Write this version of MY-REVERSE.
(defun my-reverse-recursive... | 509 | Common Lisp | .lisp | 13 | 36.846154 | 69 | 0.717791 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | f2894f8366292eab89bfd95054a571084c22bbb15c440421c7e08c947f5d9e3b | 17,027 | [
-1
] |
17,028 | ex-08-47.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-47.lisp | ; file: ex-08-47.lisp
; author: Jon David
; date: Sunday, September 28, 2014
; description:
; exercise 8.47 - Write MAKE-LOAf, a function that returns a loaf of
; size N. (MAKE-LOAF 4) should return (X X X X). Use IF instead of
; COND.
(defun make-loaf (n)
(if (zerop n)
nil
(cons 'X (make-loaf (- ... | 333 | Common Lisp | .lisp | 11 | 27.545455 | 70 | 0.640379 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 7e67c970e9647bca8ccd904b11612917f5b4b9b1df2591f22fd3cd796caa23e1 | 17,028 | [
-1
] |
17,029 | ex-08-44.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-44.lisp | ; file: ex-08-44.lisp
; author: Jon David
; date: Wednesday, September 24, 2014
; description:
; exercise 8.44 - Write a function TREE-DEPTH that returns the
; maximum depth of a binary tree. (TREE-DEPTH '(a . b)) should
; return one. (TREE-DEPTH '((A B C D))) should return five, and
; (TREE-DEPTH '((A . B) .... | 1,185 | Common Lisp | .lisp | 30 | 38.2 | 66 | 0.643539 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | b9e998dad128900210bc7052bdeb5e39bcb9c03f1e17693ca5dae68379206447 | 17,029 | [
-1
] |
17,030 | ex-08-61.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-61.lisp | ; file: ex-08-61.lisp
; author: Jon David
; date: Monday, October 21, 2014
; description:
; exercise 8.61 - Write a tail-recursive version of COUNT-UP.
(defun count-up (loaf)
(tr-count-up loaf 0))
(defun tr-count-up (loaf count)
(cond ((null loaf) count)
(t (tr-count-up (cdr loaf) (1+ count)))))
(defun ut-ex-... | 442 | Common Lisp | .lisp | 15 | 27.2 | 63 | 0.659574 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | a3139d5168ccacccf20f308cec86e8896c3b40b3f9f04d0255cefb1a27e224de | 17,030 | [
-1
] |
17,031 | ex-08-10.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-10.lisp | ; file: ex-08-10.lisp
; author: Jon David
; date: Monday, August 18, 2014
; description:
; exercise 8.10 - For x a nonnegative integer and y a positive
; integer, x+y equals x + 1 + (y - 1).
; If y is zero then x+y equals x. Use these equations to build
; a recursive version of + called REC-PLUS out of ADD1, SU... | 502 | Common Lisp | .lisp | 16 | 29.625 | 64 | 0.663202 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 56faf94b20cdccae45cce90c1f5f978b63801aaf8ba7e98be4c94ed028ad4ca6 | 17,031 | [
-1
] |
17,032 | ex-08-07.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-07.lisp | ; file: ex-08-07.lisp
; author: Jon David
; date: Monday, August 18, 2014
; description:
; exercise 8.7 - Write a recursive version of MEMBER. Call it
; REC-MEMBER so you don't redefine the built-in MEMBER function.
(defun rec-member (item list)
(cond ((null list) nil)
(t (or (equal item (car list)) (rec-member... | 344 | Common Lisp | .lisp | 9 | 36.555556 | 66 | 0.701807 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 7d463a9c4d6471e1971eebb142fe78b3bb836293f2cd43f42d0f81916a7cfb5c | 17,032 | [
-1
] |
17,033 | ex-08-33.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-33.lisp | ; file: ex-08-33.lisp
; author: Jon David
; date: Sunday, August 24, 2014
; description:
; exercise 8.33 - Write my-remove, a recursive version of the REMOVE
; function.
(defun my-remove (x list)
(cond ((null list) nil)
((equal x (car list)) (my-remove x (cdr list)))
(t (cons (car list) (my-remove x (cdr list)... | 326 | Common Lisp | .lisp | 10 | 31.1 | 70 | 0.669841 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 40a75e352bf5dde1bc8926f44e8631dff083974ab1cea3490147aeecb2c65413 | 17,033 | [
-1
] |
17,034 | ex-08-67.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-67.lisp | ; file: ex-08-67.lisp
; author: Jon David
; date: Saturday, November 15, 2014
; description:
; Write a predicate LEGALP that returns T if its input is a legal
; arithmetic expression. For example, (LEGALP 4) and
; (LEGALP '((2 * 2) - 3)) should return T. (LEGALP NIL) and
; (LEGALP '(A B C D)) should return NIL.... | 400 | Common Lisp | .lisp | 11 | 35.090909 | 67 | 0.680412 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 687a2e7dafd0fe4f0fd6b45936c1c169ba583cd36aae885700c60191d5590c92 | 17,034 | [
-1
] |
17,035 | ex-08-57.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-57.lisp | ; file: ex-08-57.lisp
; author: Jon David
; date: Monday, September 29, 2014
; description:
; exercise 8.57 - Write LEFT-HALF, a recursive function in two parts
; that returns the first n/2 elements of a list of length n. Write
; your function so that the list does not have to be of even length.
; (LEFT-HALF '... | 680 | Common Lisp | .lisp | 15 | 43.533333 | 70 | 0.675266 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | d8a399be66d61ae650f36acf4a7ee0bdaf1a8aa423169d0b835cd869c88b448d | 17,035 | [
-1
] |
17,036 | ex-08-62.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-62.lisp | ; file: ex-08-62.lisp
; author: Jon David
; date: Monday, October 21, 2014
; description:
; exercise 8.62 - Write a tail-recursive version of FACT.
(defun my-fact (n)
(tr-fact n 1))
(defun tr-fact (n product)
(cond ((zerop n) product)
(t (tr-fact (- n 1) (* product n)))))
(defun ut-ex-08-62 ()
(let* ((n 4)... | 397 | Common Lisp | .lisp | 15 | 24.2 | 59 | 0.62963 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 14df651baafcf337a2500457da6a9e2612971f51ad03a0a632b0efb478e62ed1 | 17,036 | [
-1
] |
17,037 | ex-08-08.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-08.lisp | ; file: ex-08-08.lisp
; author: Jon David
; date: Monday, August 18, 2014
; description:
; exercise 8.8 - Write a recursive version of ASSOC. Call it
; REC-ASSOC.
(defun rec-assoc (index table)
(let ((first-item (car table)))
(cond ((null table) nil)
((equal index (car first-item)) first-item)
(t (rec-... | 351 | Common Lisp | .lisp | 11 | 29.545455 | 62 | 0.670623 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 6b650899c67ac16d1caa3eead0d10fd706550c8638fa288d7094636a3541351b | 17,037 | [
-1
] |
17,038 | ex-08-42.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-42.lisp | ; file: ex-08-42.lisp
; author: Jon David
; date: Wednesday, September 24, 2014
; description:
; exercise 8.42 - Write MY-SUBST, a recursive version of the
; SUBST function.
;
; usage:
; (load "ex-08-42.lisp")
; (my-subst 'a 'b '(a b c)) => (A A C)
; (my-subst 'a '(b c) '(a (b c) d e)) => (A A D E)
(defun my... | 469 | Common Lisp | .lisp | 16 | 27.875 | 62 | 0.609272 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 6bac0f83209fac3603dc61966884ee6cf0a4b131da123b8be900439a88779b06 | 17,038 | [
-1
] |
17,039 | ex-08-32.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-32.lisp | ; file: ex-08-32.lisp
; author: Jon David
; date: Sunday, August 24, 2014
; description:
; exercise 8.32 - Write the function SUM-NUMERIC-ELEMENTS, which
; adds up all the numbers in a list and ignores the non-numbers.
; (SUM-NUMERIC-ELEMENTS '(3 BEARS 3 BOWLS AND 1 GIRL)) should
; return 7.
(defun sum-numeric... | 478 | Common Lisp | .lisp | 13 | 35.153846 | 66 | 0.697624 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 52c923cbe01d3be368e097c3cff2241340d3f717773398f8bbbb581b04718848 | 17,039 | [
-1
] |
17,040 | ex-08-48.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-48.lisp | ; file: ex-08-48.lisp
; author: Jon David
; date: Sunday, September 28, 2014
; description:
; exercise 8.48 - Write a recursive function BURY that buries an
; item under n levels of parentheses. (BURY 'FRED 2) should return
; ((FRED)), while (BURY 'FRED 5) should return (((((FRED))))). Which
; recursion templat... | 432 | Common Lisp | .lisp | 11 | 37.545455 | 70 | 0.682692 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 98464cf667ead380809e36affada1714020a3395a071ba400d8455bd25957418 | 17,040 | [
-1
] |
17,041 | ex-08-60-keyboard-exercise.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-60-keyboard-exercise.lisp | ; file: ex-08-60.lisp
; author: Jon David
; date: Monday, September 29, 2014
; description:
; exercise 8.60 - If the genealogy database is already stored on
; the computer for you, load the file containing it. If not, you
; will have to type it in as it appears in Figure 8-12. Store the
; database in the globa... | 6,684 | Common Lisp | .lisp | 166 | 36.614458 | 70 | 0.671136 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 2291e1a15bcdcf834cb18464ece72742af37bf5e25360fba1d708a8eff8900a0 | 17,041 | [
-1
] |
17,042 | ex-08-70.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-70.lisp | ; file: ex-08-70.lisp
; author: Jon David
; date: Saturday, November 15, 2014
; description:
; Following is a function FACTORS that returns the list of prime
; factors of a number. It uses the built-in REM function to compute
; the remainder of dividing one number by another. (FACTORS 60)
; returns (2 2 3 5). T... | 971 | Common Lisp | .lisp | 27 | 34.555556 | 69 | 0.635494 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 99dfee5fcbe59552807212faf415627c5a4e38426bef2317fa4bba0116f10f50 | 17,042 | [
-1
] |
17,043 | ex-08-39.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-39.lisp | ; file: ex-08-39.lisp
; author: Jon David
; date: Wednesday, September 24, 2014
; description:
; exercise 8.39 - Write a function COUNT-ATOMS that returns the
; number of atoms in a tree. (COUNT-ATOMS '(A (B) C)) should return
; five, since in addition to A, B, and C there are two NILs in the
; tree.
;
; usage... | 499 | Common Lisp | .lisp | 17 | 27.647059 | 70 | 0.634096 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | ff38cccc304099b0b70c1ab61e854fc58ec4e9ed0caa3671101ae25211e27747 | 17,043 | [
-1
] |
17,044 | ex-08-25.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-25.lisp | ; file: ex-08-25.lisp
; author: Jon David
; date: Sunday, August 24, 2014
; description:
; exercise 8.25 - How could COUNT-DOWN be used to write an
; applicative version of FACT? (You may skip this problem if you
; haven't read Chapter 7 yet).
(defun count-down (n)
(cond ((zerop n) nil)
(t (cons n (count-down... | 381 | Common Lisp | .lisp | 12 | 30.25 | 66 | 0.668478 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | ad51ac7faa8fd63ebc28a63afc29372b40275214180a7d0b277dfc0be7af8f94 | 17,044 | [
-1
] |
17,045 | ex-08-04.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-04.lisp | ; file: ex-08-04.lisp
; author: Jon David
; date: Monday, August 18, 2014
; description:
; exercise 8.4 - We are going to write a function called LAUGH that
; takes a number as input and returns a list of that many HAs.
; (LAUGH 3) should return the list (HA HA HA). (LAUGH 0) should
; return a list with no HAs ... | 461 | Common Lisp | .lisp | 12 | 36.833333 | 69 | 0.674157 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 3bcbc691425182db2566c34836e0e02348d7d5ceebe43714b32c03c9efdcc338 | 17,045 | [
-1
] |
17,046 | ex-08-65.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-65.lisp | ; file: ex-08-65.lisp
; author: Jon David
; date: Monday, October 21, 2014
; description:
; exercise 8.65 - Use LABELS to write versions of TR-COUNT-SLICES
; and TR-REVERSE.
(defun count-slices (loaf)
(labels ((tr-count-slices (loaf count)
(cond ((null loaf) count)
(t (tr-count-slices (cdr loaf) (1+ c... | 502 | Common Lisp | .lisp | 16 | 28.5 | 67 | 0.654244 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 7978b192c916f0674167537e5efa8cb83daca9577eaab48c0c2230c1db071778 | 17,046 | [
-1
] |
17,047 | ex-08-06.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-06.lisp | ; file: ex-08-06.lisp
; author: Jon David
; date: Monday, August 18, 2014
; description:
; exercise 8.6 - Write ALLODDP, a recursive function that returns T
; if all the numbers in a list are odd.
(defun alloddp (num-list)
(cond ((null num-list) t)
(t (and (oddp (car num-list)) (alloddp (cdr num-list))))))
| 318 | Common Lisp | .lisp | 9 | 33.666667 | 69 | 0.689542 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | d2d898c25de54cb3992829a1c671d7738f4be15c699090a23e5944443f9f8df1 | 17,047 | [
-1
] |
17,048 | ex-08-63.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-63.lisp | ; file: ex-08-63.lisp
; author: Jon David
; date: Monday, October 21, 2014
; description:
; exercise 8.63 - Write tail-recursive versions of UNION,
; INTERSECTION, and SET-DIFFERENCE. Your functions need not return
; results in the same order as the built-in functions.
(defun my-union (X Y)
(tr-my-union X Y Y... | 659 | Common Lisp | .lisp | 19 | 32.526316 | 69 | 0.663522 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 8abf634be143215fc1e3cd27c6dae5a9b17b825f63aec0c25475776897f9909f | 17,048 | [
-1
] |
17,049 | ex-08-18.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-18.lisp | ; file: ex-08-18.lisp
; author: Jon David
; date: Sunday, August 24, 2014
; description:
; exercise 8.18 - Use single-test tail recursion to write
; LAST-ELEMENT, a function that returns the last element of a list.
; LAST-ELEMENT should recursively travel down the list until it
; reaches the last cons cell (a c... | 495 | Common Lisp | .lisp | 12 | 39.916667 | 69 | 0.719917 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | b4bb451d0fa49e96899a8bb0ef375749bf5297cb659f2dbbd8c2de85e700a5bf | 17,049 | [
-1
] |
17,050 | ex-08-29.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-29.lisp | ; file: ex-08-29.lisp
; author: Jon David
; date: Sunday, August 24, 2014
; description:
; exercise 8.29 - Write MY-MEMBER, a recursive version of MEMBER.
; This function will take two inputs, but you will only want to
; reduce one of them with each successive call. The other should
; remain unchanged.
(defun ... | 434 | Common Lisp | .lisp | 12 | 34.833333 | 67 | 0.71327 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 8ae5597e52a6c5f309f4bbb041c1556b9c3d8deaaa38de67d79d775c11584d78 | 17,050 | [
-1
] |
17,051 | ex-08-35.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-35.lisp | ; file: ex-08-35.lisp
; author: Jon David
; date: Monday, August 25, 2014
; description:
; exercise 8.35 - Write MY-SET-DIFFERENCE, a recursive version of
; the SET-DIFFERENCE function.
; Note: X-Y is not necessarily equal to Y-X.
(defun my-set-difference (X Y)
(cond ((null X) nil)
((null Y) X)
((member (car X... | 408 | Common Lisp | .lisp | 12 | 32.5 | 67 | 0.673418 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 509f1d4d4bb8d0115ffb3ee3caacd3921f408d75da79d2a4f28e0fef064b1fbe | 17,051 | [
-1
] |
17,052 | ex-08-49.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-49.lisp | ; file: ex-08-49.lisp
; author: Jon David
; date: Sunday, September 28, 2014
; description:
; exercise 8.49 - Write PAIRINGS, a function that pairs the elements
; of two lists. (PAIRINGS '(A B C) '(1 2 3)) should return
; ((A 1) (B 2) (C 3)). You may assume that the two lists will be of
; equal length.
(defun ... | 490 | Common Lisp | .lisp | 12 | 38.916667 | 70 | 0.674419 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 9353875564fa7a5ed414cd25af7ba700d174557b9bb8fb0a7f0b557ba09f5bee | 17,052 | [
-1
] |
17,053 | ex-08-34.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-34.lisp | ; file: ex-08-34.lisp
; author: Jon David
; date: Monday, August 25, 2014
; description:
; exercise 8.34 - Write MY-INTERSECTION, a recursive version of the
; INTERSECTION function.
(defun my-intersection (X Y)
(cond ((or (null X) (null Y)) nil)
((member (car X) Y)
(cons (car X) (my-intersection (cdr X) Y)))
... | 355 | Common Lisp | .lisp | 11 | 30.636364 | 69 | 0.673469 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 61a46abedb456faf99253e463077eddff138bb6b3e798abe19755bcd72821786 | 17,053 | [
-1
] |
17,054 | ex-08-54.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-54.lisp | ; file: ex-08-54.lisp
; author: Jon David
; date: Sunday, September 28, 2014
; description:
; exercise 8.54 - Write a recursive function HUGE that raises a
; number to its own power. (HUGE 2) should return 2^2=4. (HUGE 3)
; should return 3^3=27, (HUGE 4) should return 4^4=256, and so on.
; Do not use REDUCE.
(... | 475 | Common Lisp | .lisp | 13 | 34.615385 | 68 | 0.679121 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 6020545b4a5ad7eb5f76b15e01e44548a4c5f737a6e7213ee3609776c934d048 | 17,054 | [
-1
] |
17,055 | ex-08-30.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-30.lisp | ; file: ex-08-30.lisp
; author: Jon David
; date: Sunday, August 24, 2014
; description:
; exercise 8.30 - Write MY-ASSOC, a recursive version of ASSOC.
(defun my-assoc (key table)
(cond ((null table) nil)
((equal key (caar table)) (car table))
(t (my-assoc key (cdr table)))))
| 285 | Common Lisp | .lisp | 9 | 30.111111 | 65 | 0.683636 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 3558219275fee98010e938fc93e9c4d9f11de9b1b872df9a4968f297a10b1bba | 17,055 | [
-1
] |
17,056 | ex-08-66.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-66.lisp | ; file: ex-08-66.lisp
; author: Jon David
; date: Monday, October 21, 2014
; description:
; exercise 8.66 - Write ARITH-EVAL, a function that evalutes
; arithmetic expressions. (ARITH-EVAL '(2 + (3 * 4))) should
; return 14.
;
; notes:
; An arithmetic expression is either a number, or a three-element
; list w... | 626 | Common Lisp | .lisp | 20 | 29.5 | 67 | 0.682645 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 06a7e98a2a0f44ee1639dbaded547a0603f140a48d6954a2f75f79b922195a89 | 17,056 | [
-1
] |
17,057 | ex-08-31.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-31.lisp | ; file: ex-08-31.lisp
; author: Jon David
; date: Sunday, August 24, 2014
; description:
; exercise 8.31 - Suppose we want to tell as quickly as possible
; whether one list is shorter than another. If one list has five
; elements and the other has a million, we don't want to have to
; go through all one million... | 864 | Common Lisp | .lisp | 18 | 46.555556 | 68 | 0.734597 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 9168ac7d2aed2f8c89c3eac7a768ed504c6b24039fb0142ebea0ac6e213e7424 | 17,057 | [
-1
] |
17,058 | ex-08-45.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-45.lisp | ; file: ex-08-45.lisp
; author: Jon David
; date: Wednesday, September 24, 2014
; description:
; exercise 8.45 - Write a function PAREN-DEPTH that returns the
; maximum depth of nested parentheses in a list.
; (PAREN-DEPTH '(A B C)) should return one, whereas TREE-DEPTH
; would return three. (PAREN-DEPTH '(A B... | 680 | Common Lisp | .lisp | 17 | 38.705882 | 69 | 0.701357 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 95c2c51b8c7154a1226916c2020c252935037ccf78893132c48a1b6c823f28e3 | 17,058 | [
-1
] |
17,059 | ex-08-27.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-27.lisp | ; file: ex-08-27.lisp
; author: Jon David
; date: Sunday, August 24, 2014
; description:
; exercise 8.27 - Write SQUARE-LIST, a recursive function that takes
; a list of numbers as input and returns a list of their squares.
; (SQUARE-LIST '(3 4 5 6)) should return (9 16 25 36).
(defun square-list (num-list)
(c... | 425 | Common Lisp | .lisp | 11 | 37.090909 | 70 | 0.681159 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 66fd3779afa0bd1e27c4b69475fcb3ac81b2bff96fc0cc60347bc071f88f38bf | 17,059 | [
-1
] |
17,060 | ex-08-05.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-05.lisp | ; file: ex-08-05.lisp
; author: Jon David
; date: Monday, August 18, 2014
; description:
; exercise 8.5 - In this exercise we are going to write a function
; ADD-UP to add up all the numbers in a list. (ADD-UP '(2 3 7))
; should return 12. You already know how to solve this problem
; applicatively with REDUCE; ... | 476 | Common Lisp | .lisp | 12 | 38.166667 | 68 | 0.689805 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 21994a0ee4a0c4d2e2c6ea96a5a4a626a9764acf364c9315773cc7f8635dd286 | 17,060 | [
-1
] |
17,061 | ex-08-46.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-46.lisp | ; file: ex-08-46.lisp
; author: Jon David
; date: Sunday, September 28, 2014
; description:
; exercise 8.46 - Another way to solve the problem of counting
; upward is to add an element to the end of the list with each
; recursive call instead of adding elements to the beginning.
; This approach doesn't require ... | 469 | Common Lisp | .lisp | 12 | 37.416667 | 64 | 0.712389 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | f99955386f119b3c11f3751dc8a29da57daeb5022816079590c192be8af6cff4 | 17,061 | [
-1
] |
17,062 | ex-08-17.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-17.lisp | ; file: ex-08-17.lisp
; author: Jon David
; date: Sunday, August 24, 2014
; description:
; exercise 8.17 - Use double-test tail recursion to write
; FIND-FIRST-ODD, a function that returns the first odd number in a
; list, or NIL if there are none. Start by copying the recursion
; template for ANYODDP; only a s... | 528 | Common Lisp | .lisp | 14 | 35.785714 | 69 | 0.695906 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 926cbf4b92cce6ba1a69a63028efaca3fd4daa296a3bbd7ab05cc81365de09c9 | 17,062 | [
-1
] |
17,063 | ex-08-21.lisp | joncdavid_touretzky-lisp-exercises/chp8-recursion/ex-08-21.lisp | ; file: ex-08-21.lisp
; author: Jon David
; date: Sunday, August 24, 2014
; description:
; exercise 8.21 - Write a recursive function ADD-NUMS that adds up
; the numbers N, N-1, N-2, and so on, down to 0, and returns the
; result. For example, (ADD-NUMS 5) should compute 5+4+3+2+1+0=15.
(defun add-nums (n)
(co... | 370 | Common Lisp | .lisp | 10 | 35.5 | 68 | 0.653631 | joncdavid/touretzky-lisp-exercises | 3 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:27:44 AM (Europe/Amsterdam) | 44f9fdcbf54e89a87d67a06490b4f340eaf587d0b2ff6cd3c18ba1066631c5ed | 17,063 | [
-1
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.