/
data_set.clj
593 lines (527 loc) · 25.5 KB
/
data_set.clj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
(ns foreclojure.data-set
(:use [somnium.congomongo]))
(defn load-problems []
(do
(mongo! :db :mydb)
(insert! :problems
{:_id 1
:title "Nothing but the Truth"
:times-solved 0
:description "This is a clojure form. Enter a value which will make the form evaluate to true. Don't over think it! If you are confused, see the <a href='/directions'>getting started</a> page."
:tags ["elementary"]
:tests ["(= __ true)"]})
(insert! :problems
{:_id 2
:title "Simple Math"
:times-solved 0
:description "If you are not familiar with <a href='http://en.wikipedia.org/wiki/Polish_notation'>polish notation</a>, simple arithmetic might seem confusing."
:tags ["elementary"]
:tests ["(= (- 10 (* 2 3)) __)"]})
(insert! :problems
{:_id 3
:title "Intro to Strings"
:times-solved 0
:description "Clojure strings are Java strings. This means that you can use any of the Java string methods on Clojure strings."
:tags["elementary"]
:tests ["(= __ (.toUpperCase \"hello world\"))"]})
(insert! :problems
{:_id 4
:title "Intro to Lists"
:times-solved 0
:description "Lists can be constructed with either a function or a quoted form."
:tags["elementary"]
:tests ["(= (list __) '(:a :b :c))"]})
(insert! :problems
{:_id 5
:title "Lists: conj"
:times-solved 0
:description "When operating on a list, the conj function will return a new list with one or more items \"added\" to the front."
:tags["elementary"]
:tests ["(= __ (conj '(2 3 4) 1))"
"(= __ (conj '(3 4) 2 1))"]})
(insert! :problems
{:_id 6
:title "Intro to Vectors"
:times-solved 0
:description "Vectors can be constructed several ways. You can compare them with lists."
:tags["elementary"]
:tests ["(= [__] (list :a :b :c) (vec '(:a :b :c)) (vector :a :b :c))"]})
(insert! :problems
{:_id 7
:title "Vectors: conj"
:times-solved 0
:description "When operating on a Vector, the conj function will return a new vector with one or more items \"added\" to the end."
:tags["elementary"]
:tests ["(= __ (conj [1 2 3] 4))"
"(= __ (conj [1 2] 3 4))"]})
(insert! :problems
{:_id 8
:title "Intro to Sets"
:times-solved 0
:description "Sets are collections of unique values."
:tags["elementary"]
:tests ["(= __ (set '(:a :a :b :c :c :c :c :d :d)))"
"(= __ (clojure.set/union #{:a :b :c} #{:b :c :d}))"]})
(insert! :problems
{:_id 9
:title "Sets: conj"
:times-solved 0
:description "When operating on a set, the conj function returns a new set with one or more keys \"added\"."
:tags["elementary"]
:tests ["(= #{1 2 3 4} (conj #{1 4 3} __))"]})
(insert! :problems
{:_id 10
:title "Intro to Maps"
:times-solved 0
:description "Maps store key-value pairs. Both maps and keywords can be used as lookup functions. Commas can be used to make maps more readable, but they are not required."
:tags["elementary"]
:tests ["(= __ ((hash-map :a 10, :b 20, :c 30) :b))"
"(= __ (:b {:a 10, :b 20, :c 30}))"]})
(insert! :problems
{:_id 11
:title "Maps: conj"
:times-solved 0
:description "When operating on a map, the conj function returns a new map with one or more key-value pairs \"added\"."
:tags["elementary"]
:tests ["(= {:a 1, :b 2, :c 3} (conj {:a 1} __ [:c 3]))"]})
(insert! :problems
{:_id 12
:title "Intro to Sequences"
:times-solved 0
:description "All Clojure collections support sequencing. You can operate on sequences with functions like first, second, and last."
:tags["elementary"]
:tests ["(= __ (first '(3 2 1)))"
"(= __ (second [2 3 4]))"
"(= __ (last (list 1 2 3)))"]})
(insert! :problems
{:_id 13
:title "Sequences: rest"
:times-solved 0
:description "The rest function will return all the items of a sequence except the first."
:tags["elementary"]
:tests ["(= __ (rest [10 20 30 40]))"]})
(insert! :problems
{:_id 14
:title "Intro to Functions"
:times-solved 0
:description "Clojure has many different ways to create functions."
:tags["elementary"]
:tests ["(= __ ((fn add-five [x] (+ x 5)) 3))"
"(= __ ((fn [x] (+ x 5)) 3))"
"(= __ (#(+ % 5) 3))"
"(= __ ((partial + 5) 3))"]})
(insert! :problems
{:_id 15
:title "Double Down"
:times-solved 0
:description "Write a function which doubles a number."
:tags ["elementary"]
:tests ["(= (__ 2) 4)"
"(= (__ 3) 6)"
"(= (__ 11) 22)"
"(= (__ 7) 14)"]})
(insert! :problems
{:_id 16
:title "Hello World"
:times-solved 0
:description "Write a function which returns a personalized greeting."
:tags ["elementary"]
:tests ["(= (__ \"Dave\") \"Hello, Dave!\")"
"(= (__ \"Jenn\") \"Hello, Jenn!\")"
"(= (__ \"Rhea\") \"Hello, Rhea!\")"]})
(insert! :problems
{:_id 17
:title "Sequences: map"
:times-solved 0
:description "The map function takes two arguments: a function (f) and a sequence (s). Map returns a new sequence consisting of the result of applying f to each item of s. Do not confuse the map function with the map data structure."
:tags["elementary"]
:tests ["(= __ (map #(+ % 5) '(1 2 3)))"]})
(insert! :problems
{:_id 18
:title "Sequences: filter"
:times-solved 0
:description "The filter function takes two arguments: a predicate function (f) and a sequence (s). Filter returns a new sequence consisting of all the items of s for which (f item) returns true."
:tags["elementary"]
:tests ["(= __ (filter #(> % 5) '(3 4 5 6 7)))"]})
(insert! :problems
{:_id 19
:title "Last Element"
:times-solved 0
:restricted ["last"]
:description "Write a function which returns the last element in a sequence."
:tags ["easy" "seqs" "core-functions"]
:tests ["(= (__ [1 2 3 4 5]) 5)"
"(= (__ '(5 4 3)) 3)"
"(= (__ [\"b\" \"c\" \"d\"]) \"d\")"]})
(insert! :problems
{:_id 20
:title "Penultimate Element"
:times-solved 0
:description "Write a function which returns the second to last element from a sequence."
:tags["easy" "seqs"]
:tests ["(= (__ (list 1 2 3 4 5)) 4)"
"(= (__ [\"a\" \"b\" \"c\"]) \"b\")"
"(= (__ [[1 2] [3 4]]) [1 2])"]})
(insert! :problems
{:_id 21
:title "Nth Element"
:times-solved 0
:restricted ["nth"]
:description "Write a function which returns the Nth element from a sequence."
:tags["easy" "seqs" "core-functions"]
:tests ["(= (__ '(4 5 6 7) 2) 6)"
"(= (__ [:a :b :c] 0) :a)"
"(= (__ [1 2 3 4] 1) 2)"
"(= (__ '([1 2] [3 4] [5 6]) 2) [5 6])"]})
(insert! :problems
{:_id 22
:title "Count a Sequence"
:times-solved 0
:restricted ["count"]
:description "Write a function which returns the total number of elements in a sequence."
:tags["easy" "seqs" "core-functions"]
:tests ["(= (__ '(1 2 3 3 1)) 5)"
"(= (__ \"Hello World\") 11)"
"(= (__ [[1 2] [3 4] [5 6]]) 3)"
"(= (__ '(13)) 1)"
"(= (__ '(:a :b :c)) 3)"]})
(insert! :problems
{:_id 23
:title "Reverse a Sequence"
:times-solved 0
:restricted ["reverse"]
:description "Write a function which reverses a sequence."
:tags["easy" "seqs" "core-functions"]
:tests ["(= (__ [1 2 3 4 5]) [5 4 3 2 1])"
"(= (__ (sorted-set 5 7 2 7)) '(7 5 2))"
"(= (__ [[1 2][3 4][5 6]]) [[5 6][3 4][1 2]])"]})
(insert! :problems
{:_id 24
:title "Sum It All Up"
:times-solved 0
:description "Write a function which returns the sum of a sequence of numbers."
:tags ["easy" "seqs"]
:tests ["(= (__ [1 2 3]) 6)"
"(= (__ (list 0 -2 5 5)) 8)"
"(= (__ #{4 2 1}) 7)"
"(= (__ '(0 0 -1)) -1)"
"(= (__ '(1 10 3)) 14)"]})
(insert! :problems
{:_id 25
:title "Find the odd numbers"
:times-solved 0
:description "Write a function which returns only the odd numbers from a sequence."
:tags["easy" "seqs"]
:tests ["(= (__ #{1 2 3 4 5}) '(1 3 5))"
"(= (__ [4 2 1 6]) '(1))"
"(= (__ [2 2 4 6]) '())"
"(= (__ [1 1 1 3]) '(1 1 1 3))"]})
(insert! :problems
{:_id 26
:title "Fibonacci Sequence"
:times-solved 0
:description "Write a function which returns the first X fibonacci numbers."
:tags["easy" "Fibonacci" "seqs"]
:tests ["(= (__ 3) '(1 1 2))"
"(= (__ 6) '(1 1 2 3 5 8))"
"(= (__ 8) '(1 1 2 3 5 8 13 21))"]})
(insert! :problems
{:_id 27
:title "Palindrome Detector"
:times-solved 0
:description "Write a function which returns true if the given sequence is a palindrome.<br/><br>
Hint: \"racecar\" does not equal '(\\r \\a \\c \\e \\c \\a \\r)"
:tags["easy" "seqs"]
:tests ["(false? (__ '(1 2 3 4 5)))"
"(true? (__ \"racecar\"))"
"(true? (__ [:foo :bar :foo]))"
"(true? (__ '(1 1 3 3 1 1)))"
"(false? (__ '(:a :b :c)))"]})
(insert! :problems
{:_id 28
:title "Flatten a Sequence"
:times-solved 0
:restricted ["flatten"]
:description "Write a function which flattens a sequence."
:tags["easy" "seqs" "core-functions"]
:tests ["(= (__ '((1 2) 3 [4 [5 6]])) '(1 2 3 4 5 6))"
"(= (__ [\"a\" [\"b\"] \"c\"]) '(\"a\" \"b\" \"c\"))"
"(= (__ '((((:a))))) '(:a))"]})
(insert! :problems
{:_id 29
:title "Get the Caps"
:times-solved 0
:description "Write a function which takes a string and returns a new string containing only the capital letters."
:tags["easy" "strings"]
:tests ["(= (__ \"HeLlO, WoRlD!\") \"HLOWRD\")"
"(empty? (__ \"nothing\"))"
"(= (__ \"$#A(*&987Zf\") \"AZ\")"]})
(insert! :problems
{:_id 30
:title "Compress a Sequence"
:times-solved 0
:description "Write a function which removes consecutive duplicates from a sequence."
:tags ["easy" "seqs"]
:tests ["(= (apply str (__ \"Leeeeeerrroyyy\")) \"Leroy\")"
"(= (__ [1 1 2 3 3 2 2 3]) '(1 2 3 2 3))"
"(= (__ [[1 2] [1 2] [3 4] [1 2]]) '([1 2] [3 4] [1 2]))"]})
(insert! :problems
{:_id 31
:title "Pack a Sequence"
:times-solved 0
:description "Write a function which packs consecutive duplicates into sub-lists."
:tags ["easy" "seqs"]
:tests ["(= (__ [1 1 2 1 1 1 3 3]) '((1 1) (2) (1 1 1) (3 3)))"
"(= (__ [:a :a :b :b :c]) '((:a :a) (:b :b) (:c)))"
"(= (__ [[1 2] [1 2] [3 4]]) '(([1 2] [1 2]) ([3 4])))"]})
(insert! :problems
{:_id 32
:title "Duplicate a Sequence"
:times-solved 0
:description "Write a function which duplicates each element of a sequence."
:tags ["easy" "seqs"]
:tests ["(= (__ [1 2 3]) '(1 1 2 2 3 3))"
"(= (__ [:a :a :b :b]) '(:a :a :a :a :b :b :b :b))"
"(= (__ [[1 2] [3 4]]) '([1 2] [1 2] [3 4] [3 4]))"
"(= (__ [44 33]) [44 44 33 33])"]})
(insert! :problems
{:_id 33
:title "Replicate a Sequence"
:times-solved 0
:description "Write a function which replicates each element of a sequence a variable number of times."
:tags ["easy" "seqs"]
:tests ["(= (__ [1 2 3] 2) '(1 1 2 2 3 3))"
"(= (__ [:a :b] 4) '(:a :a :a :a :b :b :b :b))"
"(= (__ [4 5 6] 1) '(4 5 6))"
"(= (__ [[1 2] [3 4]] 2) '([1 2] [1 2] [3 4] [3 4]))"
"(= (__ [44 33] 2) [44 44 33 33])"]})
(insert! :problems
{:_id 34
:title "Implement range"
:times-solved 0
:restricted ["range"]
:description "Write a function which creates a list of all integers in a given range."
:tags ["easy" "seqs" "core-functions"]
:tests ["(= (__ 1 4) '(1 2 3))"
"(= (__ -2 2) '(-2 -1 0 1))"
"(= (__ 5 8) '(5 6 7))"]})
(insert! :problems
{:_id 35
:title "Local bindings"
:times-solved 0
:description "Clojure lets you give local names to values using the special let-form."
:tags ["elementary" "syntax"]
:tests ["(= __ (let [x 5] (+ 2 x)))"
"(= __ (let [x 3, y 10] (- y x)))"
"(= __ (let [x 21] (let [y 3] (/ x y))))"]})
(insert! :problems
{:_id 36
:title "Let it Be"
:times-solved 0
:description "Can you bind x, y, and z so that these are all true?"
:tags ["elementary" "math" "syntax"]
:tests ["(= 10 (let __ (+ x y)))"
"(= 4 (let __ (+ y z)))"
"(= 1 (let __ z))"]})
(insert! :problems
{:_id 37
:title "Regular Expressions"
:times-solved 0
:description "Regex patterns are supported with a special reader macro."
:tags ["elementary" "regex" "syntax"]
:tests ["(= __ (apply str (re-seq #\"[A-Z]+\" \"bA1B3Ce \")))"]})
(insert! :problems
{:_id 38
:title "Maximum value"
:times-solved 0
:restricted ["max" "max-key"]
:description "Write a function which takes a variable number of parameters and returns the maximum value."
:tags ["easy" "core-functions"]
:tests ["(= (__ 1 8 3 4) 8)"
"(= (__ 30 20) 30)"
"(= (__ 45 67 11) 67)"]})
(insert! :problems
{:_id 39
:title "Interleave Two Seqs"
:times-solved 0
:restricted ["interleave"]
:description "Write a function which takes two sequences and returns the first item from each, then the second item from each, then the third, etc."
:tags ["easy" "seqs" "core-functions"]
:tests ["(= (__ [1 2 3] [:a :b :c]) '(1 :a 2 :b 3 :c))"
"(= (__ [1 2] [3 4 5 6]) '(1 3 2 4))"
"(= (__ [1 2 3 4] [5]) [1 5])"
"(= (__ [30 20] [25 15]) [30 25 20 15])"]})
(insert! :problems
{:_id 40
:title "Interpose a Seq"
:times-solved 0
:restricted ["interpose"]
:description "Write a function which separates the items of a sequence by an arbitrary value."
:tags ["easy" "seqs" "core-functions"]
:tests ["(= (__ 0 [1 2 3]) [1 0 2 0 3])"
"(= (apply str (__ \", \" [\"one\" \"two\" \"three\"])) \"one, two, three\")"
"(= (__ :z [:a :b :c :d]) [:a :z :b :z :c :z :d])"]})
(insert! :problems
{:_id 41
:title "Drop Every Nth Item"
:times-solved 0
:description "Write a function which drops every Nth item from a sequence."
:tags ["easy" "seqs"]
:tests ["(= (__ [1 2 3 4 5 6 7 8] 3) [1 2 4 5 7 8])"
"(= (__ [:a :b :c :d :e :f] 2) [:a :c :e])"
"(= (__ [1 2 3 4 5 6] 4) [1 2 3 5 6])"]})
(insert! :problems
{:_id 42
:title "Factorial Fun"
:times-solved 0
:description "Write a function which calculates factorials."
:tags ["easy" "math"]
:tests ["(= (__ 1) 1)"
"(= (__ 3) 6)"
"(= (__ 5) 120)"
"(= (__ 8) 40320)"]})
(insert! :problems
{:_id 43
:title "Reverse Interleave"
:times-solved 0
:description "Write a function which reverses the interleave process into x number of subsequences."
:tags ["medium" "seqs"]
:tests ["(= (__ [1 2 3 4 5 6] 2) '((1 3 5) (2 4 6)))"
"(= (__ (range 9) 3) '((0 3 6) (1 4 7) (2 5 8)))"
"(= (__ (range 10) 5) '((0 5) (1 6) (2 7) (3 8) (4 9)))"]})
(insert! :problems
{:_id 44
:title "Rotate Sequence"
:times-solved 0
:description "Write a function which can rotate a sequence in either direction."
:tags ["medium" "seqs"]
:tests ["(= (__ 2 [1 2 3 4 5]) '(3 4 5 1 2))"
"(= (__ -2 [1 2 3 4 5]) '(4 5 1 2 3))"
"(= (__ 6 [1 2 3 4 5]) '(2 3 4 5 1))"
"(= (__ 1 '(:a :b :c)) '(:b :c :a))"
"(= (__ -4 '(:a :b :c)) '(:c :a :b))"]})
(insert! :problems
{:_id 45
:title "Intro to Iterate"
:times-solved 0
:description "The iterate function can be used to produce an infinite lazy sequence."
:tags ["easy" "seqs"]
:tests ["(= __ (take 5 (iterate #(+ 3 %) 1)))"]})
(insert! :problems
{:_id 46
:title "Flipping out"
:times-solved 0
:description "Write a higher-order function which flips the order of the arguments of an input function."
:tags ["medium" "higher-order-functions"]
:tests ["(= 3 ((__ nth) 2 [1 2 3 4 5]))"
"(= true ((__ >) 7 8))"
"(= 4 ((__ quot) 2 8))"
"(= [1 2 3] ((__ take) [1 2 3 4 5] 3))"]})
(insert! :problems
{:_id 47
:title "Contain Yourself"
:times-solved 0
:description "The contains? function checks if a KEY is present in a given collection. This often leads beginner clojurians to use it incorrectly with numerically indexed collections like vectors and lists."
:tags ["easy"]
:tests ["(contains? #{4 5 6} __)"
"(contains? [1 1 1 1 1] __)"
"(contains? {4 :a 2 :b} __)"
"(not (contains? '(1 2 4) __))"]})
(insert! :problems
{:_id 48
:title "Intro to some"
:times-solved 0
:description "The some function takes a predicate function and a collection. It returns the first logical true value of (predicate x) where x is an item in the collection."
:tags ["easy"]
:tests ["(= __ (some #{2 7 6} [5 6 7 8]))"
"(= __ (some #(when (even? %) %) [5 6 7 8]))"]})
(insert! :problems
{:_id 49
:title "Split a sequence"
:times-solved 0
:restricted ["split-at"]
:description "Write a function which will split a sequence into two parts."
:tags ["easy" "seqs" "core-functions"]
:tests ["(= (__ 3 [1 2 3 4 5 6]) [[1 2 3] [4 5 6]])"
"(= (__ 1 [:a :b :c :d]) [[:a] [:b :c :d]])"
"(= (__ 2 [[1 2] [3 4] [5 6]]) [[[1 2] [3 4]] [[5 6]]])"]})
(insert! :problems
{:_id 50
:title "Split by Type"
:times-solved 0
:description "Write a function which takes a sequence consisting of items with different types and splits them up into a set of homogeneous sub-sequences. The internal order of each sub-sequence should be maintained, but the sub-sequences themselves can be returned in any order (this is why 'set' is used in the test cases)."
:tags ["medium" "seqs"]
:tests ["(= (set (__ [1 :a 2 :b 3 :c])) #{[1 2 3] [:a :b :c]})"
"(= (set (__ [:a \"foo\" \"bar\" :b])) #{[:a :b] [\"foo\" \"bar\"]})"
"(= (set (__ [[1 2] :a [3 4] 5 6 :b])) #{[[1 2] [3 4]] [:a :b] [5 6]})"]})
(insert! :problems
{:_id 51
:title "Advanced Destructuring"
:times-solved 0
:description "Here is an example of some more sophisticated destructuring."
:tags ["easy" "destructuring"]
:tests ["(= [1 2 [3 4 5] [1 2 3 4 5]] (let [[a b & c :as d] __] [a b c d]))"]})
(insert! :problems
{:_id 52
:title "Intro to Destructuring"
:times-solved 0
:description "Let bindings and function parameter lists support destructuring."
:tags ["easy" "destructuring"]
:tests ["(= [2 4] (let [[a b c d e f g] (range)] __))"]})
(insert! :problems
{:_id 53
:title "Longest Increasing Sub-Seq"
:times-solved 0
:description "Given a vector of integers, find the longest consecutive sub-sequence of increasing numbers. If two sub-sequences have the same length, use the one that occurs first."
:tags ["hard" "seqs"]
:tests ["(= (__ [1 0 1 2 3 0 4 5]) [0 1 2 3])"
"(= (__ [5 6 1 3 2 7]) [5 6])"
"(= (__ [2 3 3 4 5]) [3 4 5])"
"(= (__ [7 6 5 4]) [])"]})
(insert! :problems
{:_id 54
:title "Partition a Sequence"
:times-solved 0
:restricted ["partition" "partition-all"]
:description "Write a function which returns a sequence of lists of x items each. Lists of less than x items should not be returned."
:tags ["medium" "seqs" "core-functions"]
:tests ["(= (__ 3 (range 9)) '((0 1 2) (3 4 5) (6 7 8)))"
"(= (__ 2 (range 8)) '((0 1) (2 3) (4 5) (6 7)))"
"(= (__ 3 (range 8)) '((0 1 2) (3 4 5)))"]})
(insert! :problems
{:_id 55
:title "Count Occurences"
:times-solved 0
:restricted ["frequencies"]
:description "Write a function which returns a map containing the number of occurences of each distinct item in a sequence."
:tags ["medium" "seqs" "core-functions"]
:tests ["(= (__ [1 1 2 3 2 1 1]) {1 4, 2 2, 3 1})"
"(= (__ [:b :a :b :a :b]) {:a 2, :b 3})"
"(= (__ '([1 2] [1 3] [1 3])) {[1 2] 1, [1 3] 2})"]})
(insert! :problems
{:_id 56
:title "Find Distinct Items"
:times-solved 0
:restricted ["distinct"]
:description "Write a function which removes the duplicates from a sequence. Order of the items must be maintained."
:tags ["medium" "seqs" "core-functions"]
:tests ["(= (__ [1 2 1 3 1 2 4]) [1 2 3 4])"
"(= (__ [:a :a :b :b :c :c]) [:a :b :c])"
"(= (__ '([2 4] [1 2] [1 3] [1 3])) '([2 4] [1 2] [1 3]))"]})
(insert! :problems
{:_id 56
:title "Find Distinct Items"
:times-solved 0
:restricted ["distinct"]
:description "Write a function which removes the duplicates from a sequence. Order of the items must be maintained."
:tags ["medium" "seqs" "core-functions"]
:tests ["(= (__ [1 2 1 3 1 2 4]) [1 2 3 4])"
"(= (__ [:a :a :b :b :c :c]) [:a :b :c])"
"(= (__ '([2 4] [1 2] [1 3] [1 3])) '([2 4] [1 2] [1 3]))"]})
(insert! :problems
{:_id 57
:title "Simple Recursion"
:times-solved 0
:description "A recursive function is a function which calls itself. This is one of the fundamental techniques used in functional programming."
:tags ["elementary" "recursion"]
:tests ["(= __ ((fn foo [x] (when (> x 0) (conj (foo (dec x)) x))) 5))"]})))