From b1c6b51c64ab3297acf0633594956d07ccb10c48 Mon Sep 17 00:00:00 2001 From: Blake Lewis Date: Mon, 12 Feb 2024 23:01:32 -0800 Subject: [PATCH] Circular Buffer for racket --- config.json | 8 ++ .../circular-buffer/.docs/instructions.md | 58 +++++++++ .../circular-buffer/.meta/config.json | 17 +++ .../circular-buffer/.meta/example.rkt | 32 +++++ .../practice/circular-buffer/.meta/tests.toml | 52 ++++++++ .../circular-buffer/circular-buffer-test.rkt | 114 ++++++++++++++++++ .../circular-buffer/circular-buffer.rkt | 7 ++ 7 files changed, 288 insertions(+) create mode 100644 exercises/practice/circular-buffer/.docs/instructions.md create mode 100644 exercises/practice/circular-buffer/.meta/config.json create mode 100644 exercises/practice/circular-buffer/.meta/example.rkt create mode 100644 exercises/practice/circular-buffer/.meta/tests.toml create mode 100644 exercises/practice/circular-buffer/circular-buffer-test.rkt create mode 100644 exercises/practice/circular-buffer/circular-buffer.rkt diff --git a/config.json b/config.json index a9497b2..fd7a670 100644 --- a/config.json +++ b/config.json @@ -630,6 +630,14 @@ "practices": [], "prerequisites": [], "difficulty": 2 + }, + { + "slug": "circular-buffer", + "name": "Circular Buffer", + "uuid": "fbf9d4b0-5943-4691-9bb9-f51a69c4c060", + "practices": [], + "prerequisites": [], + "difficulty": 4 } ] }, diff --git a/exercises/practice/circular-buffer/.docs/instructions.md b/exercises/practice/circular-buffer/.docs/instructions.md new file mode 100644 index 0000000..2ba1fda --- /dev/null +++ b/exercises/practice/circular-buffer/.docs/instructions.md @@ -0,0 +1,58 @@ +# Instructions + +A circular buffer, cyclic buffer or ring buffer is a data structure that uses a single, fixed-size buffer as if it were connected end-to-end. + +A circular buffer first starts empty and of some predefined length. +For example, this is a 7-element buffer: + +```text +[ ][ ][ ][ ][ ][ ][ ] +``` + +Assume that a 1 is written into the middle of the buffer (exact starting location does not matter in a circular buffer): + +```text +[ ][ ][ ][1][ ][ ][ ] +``` + +Then assume that two more elements are added — 2 & 3 — which get appended after the 1: + +```text +[ ][ ][ ][1][2][3][ ] +``` + +If two elements are then removed from the buffer, the oldest values inside the buffer are removed. +The two elements removed, in this case, are 1 & 2, leaving the buffer with just a 3: + +```text +[ ][ ][ ][ ][ ][3][ ] +``` + +If the buffer has 7 elements then it is completely full: + +```text +[5][6][7][8][9][3][4] +``` + +When the buffer is full an error will be raised, alerting the client that further writes are blocked until a slot becomes free. + +When the buffer is full, the client can opt to overwrite the oldest data with a forced write. +In this case, two more elements — A & B — are added and they overwrite the 3 & 4: + +```text +[5][6][7][8][9][A][B] +``` + +3 & 4 have been replaced by A & B making 5 now the oldest data in the buffer. +Finally, if two elements are removed then what would be returned is 5 & 6 yielding the buffer: + +```text +[ ][ ][7][8][9][A][B] +``` + +Because there is space available, if the client again uses overwrite to store C & D then the space where 5 & 6 were stored previously will be used not the location of 7 & 8. +7 is still the oldest element and the buffer is once again full. + +```text +[C][D][7][8][9][A][B] +``` diff --git a/exercises/practice/circular-buffer/.meta/config.json b/exercises/practice/circular-buffer/.meta/config.json new file mode 100644 index 0000000..2d4f921 --- /dev/null +++ b/exercises/practice/circular-buffer/.meta/config.json @@ -0,0 +1,17 @@ +{ + "authors": ["blakelewis"], + "files": { + "solution": [ + "circular-buffer.rkt" + ], + "test": [ + "circular-buffer-test.rkt" + ], + "example": [ + ".meta/example.rkt" + ] + }, + "blurb": "A data structure that uses a single, fixed-size buffer as if it were connected end-to-end.", + "source": "Wikipedia", + "source_url": "https://en.wikipedia.org/wiki/Circular_buffer" +} diff --git a/exercises/practice/circular-buffer/.meta/example.rkt b/exercises/practice/circular-buffer/.meta/example.rkt new file mode 100644 index 0000000..31d716e --- /dev/null +++ b/exercises/practice/circular-buffer/.meta/example.rkt @@ -0,0 +1,32 @@ +#lang racket + +(provide circular-buffer%) + +(define circular-buffer% + (class object% + (super-new) + (init capacity) + (define buf-size capacity) + (define buf-modulus (* 2 capacity)) + (define data (make-vector capacity)) + (define front 0) + (define back 0) + (define (buf-empty?) (= front back)) + (define (buf-full?) (= (modulo (- back front) buf-modulus) buf-size)) + (define (next-spot s) (modulo (add1 s) buf-modulus)) + (define (advance-front) (set! front (next-spot front))) + (define (advance-back) (set! back (next-spot back))) + (define/public (clear) (set! front back)) + (define/public (read) + (if (buf-empty?) + (error "buffer is empty") + (let ([v (vector-ref data (modulo front buf-size))]) + (begin (advance-front) v)))) + (define/public (write v) + (if (buf-full?) + (error "buffer is full") + (begin (vector-set! data (modulo back buf-size) v) + (advance-back)))) + (define/public (overwrite v) + (if (buf-full?) (advance-front) null) + (write v)))) diff --git a/exercises/practice/circular-buffer/.meta/tests.toml b/exercises/practice/circular-buffer/.meta/tests.toml new file mode 100644 index 0000000..0fb3143 --- /dev/null +++ b/exercises/practice/circular-buffer/.meta/tests.toml @@ -0,0 +1,52 @@ +# This is an auto-generated file. +# +# Regenerating this file via `configlet sync` will: +# - Recreate every `description` key/value pair +# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications +# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion) +# - Preserve any other key/value pair +# +# As user-added comments (using the # character) will be removed when this file +# is regenerated, comments can be added via a `comment` key. + +[28268ed4-4ff3-45f3-820e-895b44d53dfa] +description = "reading empty buffer should fail" + +[2e6db04a-58a1-425d-ade8-ac30b5f318f3] +description = "can read an item just written" + +[90741fe8-a448-45ce-be2b-de009a24c144] +description = "each item may only be read once" + +[be0e62d5-da9c-47a8-b037-5db21827baa7] +description = "items are read in the order they are written" + +[2af22046-3e44-4235-bfe6-05ba60439d38] +description = "full buffer can't be written to" + +[547d192c-bbf0-4369-b8fa-fc37e71f2393] +description = "a read frees up capacity for another write" + +[04a56659-3a81-4113-816b-6ecb659b4471] +description = "read position is maintained even across multiple writes" + +[60c3a19a-81a7-43d7-bb0a-f07242b1111f] +description = "items cleared out of buffer can't be read" + +[45f3ae89-3470-49f3-b50e-362e4b330a59] +description = "clear frees up capacity for another write" + +[e1ac5170-a026-4725-bfbe-0cf332eddecd] +description = "clear does nothing on empty buffer" + +[9c2d4f26-3ec7-453f-a895-7e7ff8ae7b5b] +description = "overwrite acts like write on non-full buffer" + +[880f916b-5039-475c-bd5c-83463c36a147] +description = "overwrite replaces the oldest item on full buffer" + +[bfecab5b-aca1-4fab-a2b0-cd4af2b053c3] +description = "overwrite replaces the oldest item remaining in buffer following a read" + +[9cebe63a-c405-437b-8b62-e3fdc1ecec5a] +description = "initial clear does not affect wrapping around" diff --git a/exercises/practice/circular-buffer/circular-buffer-test.rkt b/exercises/practice/circular-buffer/circular-buffer-test.rkt new file mode 100644 index 0000000..aac0ac8 --- /dev/null +++ b/exercises/practice/circular-buffer/circular-buffer-test.rkt @@ -0,0 +1,114 @@ +#lang racket/base + +(require racket/class) +(require "circular-buffer.rkt") + +(module+ test + (require rackunit rackunit/text-ui)) + +(module+ test + (define suite + (test-suite + "circular buffer tests" + + (test-case "reading empty buffer should fail" + (define buffer (new circular-buffer% [capacity 1])) + (check-exn exn:fail? (λ () (send buffer read)))) + + (test-case "can read an item just written" + (define buffer (new circular-buffer% [capacity 1])) + (send buffer write 1) + (check-equal? (send buffer read) 1)) + + (test-case "each item may only be read once" + (define buffer (new circular-buffer% [capacity 1])) + (send buffer write 1) + (check-equal? (send buffer read) 1) + (check-exn exn:fail? (λ () (send buffer read)))) + + (test-case "items are read in the order they are written" + (define buffer (new circular-buffer% [capacity 2])) + (send buffer write 1) + (send buffer write 2) + (check-equal? (send buffer read) 1) + (check-equal? (send buffer read) 2)) + + (test-case "full buffer can't be written to" + (define buffer (new circular-buffer% [capacity 1])) + (send buffer write 1) + (check-exn exn:fail? (λ () (send buffer write 2)))) + + (test-case "a read frees up capacity for another write" + (define buffer (new circular-buffer% [capacity 1])) + (send buffer write 1) + (check-equal? (send buffer read) 1) + (send buffer write 2) + (check-equal? (send buffer read) 2)) + + (test-case "read position is maintained even across multiple writes" + (define buffer (new circular-buffer% [capacity 3])) + (send buffer write 1) + (send buffer write 2) + (check-equal? (send buffer read) 1) + (send buffer write 3) + (check-equal? (send buffer read) 2) + (check-equal? (send buffer read) 3)) + + (test-case "items cleared out of buffer can't be read" + (define buffer (new circular-buffer% [capacity 1])) + (send buffer write 1) + (send buffer clear) + (check-exn exn:fail? (λ () (send buffer read)))) + + (test-case "clear frees up capacity for another write" + (define buffer (new circular-buffer% [capacity 1])) + (send buffer write 1) + (send buffer clear) + (send buffer write 2) + (check-equal? (send buffer read) 2)) + + (test-case "clear does nothing on empty buffer" + (define buffer (new circular-buffer% [capacity 1])) + (send buffer clear) + (send buffer write 1) + (check-equal? (send buffer read) 1)) + + (test-case "overwrite acts like write on non-full buffer" + (define buffer (new circular-buffer% [capacity 2])) + (send buffer write 1) + (send buffer overwrite 2) + (check-equal? (send buffer read) 1) + (check-equal? (send buffer read) 2)) + + (test-case "overwrite replaces the oldest item on full buffer" + (define buffer (new circular-buffer% [capacity 2])) + (send buffer write 1) + (send buffer write 2) + (send buffer overwrite 3) + (check-equal? (send buffer read) 2) + (check-equal? (send buffer read) 3)) + + (test-case "overwrite replaces the oldest item remaining in buffer following a read" + (define buffer (new circular-buffer% [capacity 3])) + (send buffer write 1) + (send buffer write 2) + (send buffer write 3) + (check-equal? (send buffer read) 1) + (send buffer write 4) + (send buffer overwrite 5) + (check-equal? (send buffer read) 3) + (check-equal? (send buffer read) 4) + (check-equal? (send buffer read) 5)) + + (test-case "initial clear does not affect wrapping around" + (define buffer (new circular-buffer% [capacity 2])) + (send buffer clear) + (send buffer write 1) + (send buffer write 2) + (send buffer overwrite 3) + (send buffer overwrite 4) + (check-equal? (send buffer read) 3) + (check-equal? (send buffer read) 4) + (check-exn exn:fail? (λ () (send buffer read)))))) + + (run-tests suite)) diff --git a/exercises/practice/circular-buffer/circular-buffer.rkt b/exercises/practice/circular-buffer/circular-buffer.rkt new file mode 100644 index 0000000..044823f --- /dev/null +++ b/exercises/practice/circular-buffer/circular-buffer.rkt @@ -0,0 +1,7 @@ +#lang racket + +(provide circular-buffer%) + +(define circular-buffer% + (class object% + (error "Not implemented yet")))