Broken link in problem-spec

glennj · October 22, 2024, 3:48pm

this pr is failing due to the link checker: details here.

The problematic link is in here: exercises/pov/metadata.toml https://www.4clojure.com/

Since <archive.org> is currently out of service, perhaps it needs to be added to the ignore file.

tasx · October 22, 2024, 4:41pm

The new site for 4clojure.com is 4clojure.oxal.org, so this could have been solved by simply updating the metadata.toml file. However, I’ve noticed that the problem referenced in the .toml file no longer exists on the new site. Therefore, adding it to the ignore file is probably the best option for now.

Cool-Katt · October 24, 2024, 1:40pm

Any idea what the particular exercise was?
Maybe it still exists on someone else’s archive or in the depths of the internet. I can try to look it up.

tasx · October 24, 2024, 2:10pm

It was this one, it’s called ‘tree reparenting’

github.com

oxalorg/4ever-clojure/blob/main/public/data/problems.json?plain=1#L125


      
          { "_id" : 117, "description" : "A mad scientist with tenure has created an experiment tracking mice in a maze.  Several mazes have been randomly generated, and you've been tasked with writing a program to determine the mazes in which it's possible for the mouse to reach the cheesy endpoint.  Write a function which accepts a maze in the form of a collection of rows, each row is a string where:\r\n<ul>\r\n<li>spaces represent areas where the mouse can walk freely</li>\r\n<li>hashes (#) represent walls where the mouse can not walk</li>\r\n<li>M represents the mouse's starting point</li>\r\n<li>C represents the cheese which the mouse must reach</li>\r\n</ul>\r\nThe mouse is not allowed to travel diagonally in the maze (only up/down/left/right), nor can he escape the edge of the maze.  Your function must return true iff the maze is solvable by the mouse.", "difficulty" : "Hard", "restricted" : null, "tags" : [ "game" ], "tests" : [ "(= true  (__ [\"M   C\"]))", "(= false (__ [\"M # C\"]))", "(= true  (__ [\"#######\"\r\n              \"#     #\"\r\n              \"#  #  #\"\r\n              \"#M # C#\"\r\n              \"#######\"]))", "(= false (__ [\"########\"\r\n              \"#M  #  #\"\r\n              \"#   #  #\"\r\n              \"# # #  #\"\r\n              \"#   #  #\"\r\n              \"#  #   #\"\r\n              \"#  # # #\"\r\n              \"#  #   #\"\r\n              \"#  #  C#\"\r\n              \"########\"]))", "(= false (__ [\"M     \"\r\n              \"      \"\r\n              \"      \"\r\n              \"      \"\r\n              \"    ##\"\r\n              \"    #C\"]))", "(= true  (__ [\"C######\"\r\n              \" #     \"\r\n              \" #   # \"\r\n              \" #   #M\"\r\n              \"     # \"]))", "(= true  (__ [\"C# # # #\"\r\n              \"        \"\r\n              \"# # # # \"\r\n              \"        \"\r\n              \" # # # #\"\r\n              \"        \"\r\n              \"# # # #M\"]))" ], "times-solved" : 0, "title" : "For Science!", "user" : "amcnamara" },
          { "_id" : 118, "description" : "<p>Map is one of the core elements of a functional programming language. Given a function <code>f</code> and an input sequence <code>s</code>, return a lazy sequence of <code>(f x)</code> for each element <code>x</code> in <code>s</code>.", "difficulty" : "Easy", "restricted" : [ "map", "map-indexed", "mapcat", "for" ], "tags" : [ "core-seqs" ], "tests" : [ "(= [3 4 5 6 7]\r\n   (__ inc [2 3 4 5 6]))", "(= (repeat 10 nil)\r\n   (__ (fn [_] nil) (range 10)))", "(= [1000000 1000001]\r\n   (->> (__ inc (range))\r\n        (drop (dec 1000000))\r\n        (take 2)))" ], "times-solved" : 0, "title" : "Re-implement Map", "user" : "semisight" },
          { "_id" : 119, "description" : "<p>As in <a href=\"/problem/73\">Problem 73</a>, a tic-tac-toe board is represented by a two dimensional vector. X is represented by :x, O is represented by :o, and empty is represented by :e. Create a function that accepts a game piece and board as arguments, and returns a set (possibly empty) of all valid board placements of the game piece which would result in an immediate win.</p>\r\n\r\n<p>Board coordinates should be as in calls to <code>get-in</code>. For example, <code>[0 1]</code> is the topmost row, center position.</p>", "difficulty" : "Hard", "restricted" : null, "tags" : [ "game" ], "tests" : [ "(= (__ :x [[:o :e :e] \r\n           [:o :x :o] \r\n           [:x :x :e]])\r\n   #{[2 2] [0 1] [0 2]})", "(= (__ :x [[:x :o :o] \r\n           [:x :x :e] \r\n           [:e :o :e]])\r\n   #{[2 2] [1 2] [2 0]})", "(= (__ :x [[:x :e :x] \r\n           [:o :x :o] \r\n           [:e :o :e]])\r\n   #{[2 2] [0 1] [2 0]})", "(= (__ :x [[:x :x :o] \r\n           [:e :e :e] \r\n           [:e :e :e]])\r\n   #{})", "(= (__ :o [[:x :x :o] \r\n           [:o :e :o] \r\n           [:x :e :e]])\r\n   #{[2 2] [1 1]})" ], "times-solved" : 8, "title" : "Win at Tic-Tac-Toe", "user" : "shockbob" },
          { "_id" : 120, "description" : "Write a function which takes a collection of integers as an argument.  Return the count of how many elements are smaller than the sum of their squared component digits.  For example: 10 is larger than 1 squared plus 0 squared; whereas 15 is smaller than 1 squared plus 5 squared.", "difficulty" : "Easy", "restricted" : null, "tags" : [ "math" ], "tests" : [ "(= 8 (__ (range 10)))", "(= 19 (__ (range 30)))", "(= 50 (__ (range 100)))", "(= 50 (__ (range 1000)))" ], "times-solved" : 0, "title" : "Sum of square of digits", "user" : "danilo" },
          { "_id" : 121, "description" : "\t Given a mathematical formula in prefix notation, return a function that calculates\r\n\t the value of the formula.\r\n\t The formula can contain nested calculations using the four basic\r\n\t mathematical operators, numeric constants, and symbols representing variables.\r\n\t The returned function has to accept a single parameter containing the map\r\n\t of variable names to their values.\r\n", "difficulty" : "Medium", "restricted" : [ "eval", "resolve" ], "tags" : [ "functions" ], "tests" : [ "(= 2 ((__ '(/ a b))\r\n      '{b 8 a 16}))", "(= 8 ((__ '(+ a b 2))\r\n      '{a 2 b 4}))", "(= [6 0 -4]\r\n     (map (__ '(* (+ 2 a)\r\n  \t              (- 10 b)))\r\n\t        '[{a 1 b 8}\r\n\t          {b 5 a -2}\r\n\t          {a 2 b 11}]))", "(= 1 ((__ '(/ (+ x 2)\r\n              (* 3 (+ y 1))))\r\n      '{x 4 y 1}))\r\n" ], "title" : "Universal Computation Engine", "user" : "mlni" },
          { "_id" : 124, "description" : "<p><a href=\"http://en.wikipedia.org/wiki/Reversi\">Reversi</a> is normally played on an 8 by 8 board. In this problem, a 4 by 4 board is represented as a two-dimensional vector with black, white, and empty pieces represented by 'b, 'w, and 'e, respectively. Create a function that accepts a game board and color as arguments, and returns a map of legal moves for that color. Each key should be the coordinates of a legal move, and its value a set of the coordinates of the pieces flipped by that move.</p>\r\n\r\n<p>Board coordinates should be as in calls to get-in. For example, <code>[0 1]</code> is the topmost row, second column from the left.</p>", "difficulty" : "Hard", "restricted" : null, "tags" : [ "game" ], "tests" : [ "(= {[1 3] #{[1 2]}, [0 2] #{[1 2]}, [3 1] #{[2 1]}, [2 0] #{[2 1]}}\r\n   (__ '[[e e e e]\r\n         [e w b e]\r\n         [e b w e]\r\n         [e e e e]] 'w))", "(= {[3 2] #{[2 2]}, [3 0] #{[2 1]}, [1 0] #{[1 1]}}\r\n   (__ '[[e e e e]\r\n         [e w b e]\r\n         [w w w e]\r\n         [e e e e]] 'b))", "(= {[0 3] #{[1 2]}, [1 3] #{[1 2]}, [3 3] #{[2 2]}, [2 3] #{[2 2]}}\r\n   (__ '[[e e e e]\r\n         [e w b e]\r\n         [w w b e]\r\n         [e e b e]] 'w))", "(= {[0 3] #{[2 1] [1 2]}, [1 3] #{[1 2]}, [2 3] #{[2 1] [2 2]}}\r\n   (__ '[[e e w e]\r\n         [b b w e]\r\n         [b w w e]\r\n         [b w w w]] 'b))\r\n" ], "title" : "Analyze Reversi", "user" : "shockbob" },
          { "_id" : 125, "description" : "Create a function of no arguments which returns a string that is an <i>exact</i> copy of the function itself.\r\n<br /><br />\r\nHint: read <a href=\"http://en.wikipedia.org/wiki/Quine_(computing)\">this</a> if you get stuck (this question is harder than it first appears); but it's worth the effort to solve it independently if you can!\r\n<br /><br />\r\nFun fact: Gus is the name of the <a href=\"http://i.imgur.com/FBd8z.png\">4Clojure dragon</a>.", "difficulty" : "Hard", "restricted" : null, "tags" : [ "logic", "fun", "brain-teaser" ], "tests" : [ "(= (str '__) (__))" ], "title" : "Gus' Quinundrum", "user" : "amcnamara" },
          { "_id" : 126, "description" : "Enter a value which satisfies the following:", "difficulty" : "Easy", "restricted" : null, "tags" : [ "fun", "brain-teaser" ], "tests" : [ "(let [x __]\r\n  (and (= (class x) x) x))" ], "title" : "Through the Looking Class", "user" : "amcnamara" },
          { "_id" : 127, "description" : "Everyone loves triangles, and it's easy to understand why&mdash;they're so wonderfully symmetric (except scalenes, they suck).\r\n<br/><br/>\r\nYour passion for triangles has led you to become a miner (and part-time Clojure programmer) where you work all day to chip out isosceles-shaped minerals from rocks gathered in a nearby open-pit mine.  There are too many rocks coming from the mine to harvest them all so you've been tasked with writing a program to analyze the mineral patterns of each rock, and determine which rocks have the biggest minerals.\r\n<br/><br/>\r\nSomeone has already written a <a href=\"http://en.wikipedia.org/wiki/Computer_vision\">computer-vision</a> system for the mine.  It images each rock as it comes into the processing centre and creates a cross-sectional <a href=\"http://en.wikipedia.org/wiki/Bit_array\">bitmap</a> of mineral (1) and rock (0) concentrations for each one.\r\n<br/><br/>\r\nYou must now create a function which accepts a collection of integers, each integer when read in base-2 gives the bit-representation of the rock (again, 1s are mineral and 0s are worthless scalene-like rock).  You must return the cross-sectional area of the largest harvestable mineral from the input rock, as follows:\r\n<br>\r\n<ul>\r\n<li>The minerals only have smooth faces when sheared vertically or horizontally from the rock's cross-section</li>\r\n<li>The mine is only concerned with harvesting isosceles triangles (such that one or two sides can be sheared)</li>\r\n<li>If only one face of the mineral is sheared, its opposing vertex must be a point (ie. the smooth face must be of odd length), and its two equal-length sides must intersect the shear face at 45&deg; (ie. those sides must cut even-diagonally)</li>\r\n<li>The harvested mineral may not contain any traces of rock</li>\r\n<li>The mineral may lie in any orientation in the plane</li>\r\n<li>Area should be calculated as the sum of 1s that comprise the mineral</li>\r\n<li>Minerals must have a minimum of three measures of area to be harvested</li>\r\n<li>If no minerals can be harvested from the rock, your function should return nil</li>\r\n</ul>", "difficulty" : "Hard", "restricted" : null, "tags" : [ "search", "data-juggling" ], "tests" : [ "(= 10 (__ [15 15 15 15 15]))\r\n; 1111      1111\r\n; 1111      *111\r\n; 1111  ->  **11\r\n; 1111      ***1\r\n; 1111      ****", "(= 15 (__ [1 3 7 15 31]))\r\n; 00001      0000*\r\n; 00011      000**\r\n; 00111  ->  00***\r\n; 01111      0****\r\n; 11111      *****", "(= 3 (__ [3 3]))\r\n; 11      *1\r\n; 11  ->  **", "(= 4 (__ [7 3]))\r\n; 111      ***\r\n; 011  ->  0*1", "(= 6 (__ [17 22 6 14 22]))\r\n; 10001      10001\r\n; 10110      101*0\r\n; 00110  ->  00**0\r\n; 01110      0***0\r\n; 10110      10110", "(= 9 (__ [18 7 14 14 6 3]))\r\n; 10010      10010\r\n; 00111      001*0\r\n; 01110      01**0\r\n; 01110  ->  0***0\r\n; 00110      00**0\r\n; 00011      000*1", "(= nil (__ [21 10 21 10]))\r\n; 10101      10101\r\n; 01010      01010\r\n; 10101  ->  10101\r\n; 01010      01010", "(= nil (__ [0 31 0 31 0]))\r\n; 00000      00000\r\n; 11111      11111\r\n; 00000  ->  00000\r\n; 11111      11111\r\n; 00000      00000" ], "title" : "Love Triangle", "user" : "amcnamara" },
          { "_id" : 128, "description" : "<p>A standard American deck of playing cards has four suits - spades, hearts, diamonds, and clubs - and thirteen cards in each suit. Two is the lowest rank, followed by other integers up to ten; then the jack, queen, king, and ace.</p>\r\n\r\n<p>It's convenient for humans to represent these cards as suit/rank pairs, such as H5 or DQ: the heart five and diamond queen respectively. But these forms are not convenient for programmers, so to write a card game you need some way to parse an input string into meaningful components. For purposes of determining rank, we will define the cards to be valued from 0 (the two) to 12 (the ace)</p>\r\n\r\n<p>Write a function which converts (for example) the string \"SJ\" into a map of <code>{:suit :spade, :rank 9}</code>. A ten will always be represented with the single character \"T\", rather than the two characters \"10\".</p>", "difficulty" : "Easy", "restricted" : null, "tags" : [ "strings", "game" ], "tests" : [ "(= {:suit :diamond :rank 10} (__ \"DQ\"))", "(= {:suit :heart :rank 3} (__ \"H5\"))", "(= {:suit :club :rank 12} (__ \"CA\"))", "(= (range 13) (map (comp :rank __ str)\r\n                   '[S2 S3 S4 S5 S6 S7\r\n                     S8 S9 ST SJ SQ SK SA]))" ], "title" : "Recognize Playing Cards", "user" : "amalloy" },
          { "_id" : 130, "description" : "Every node of a tree is connected to each of its children as\r\nwell as its parent.  One can imagine grabbing one node of\r\na tree and dragging it up to the root position, leaving all\r\nconnections intact.  For example, below on the left is\r\na binary tree.  By pulling the \"c\" node up to the root, we\r\nobtain the tree on the right.\r\n<br/>\r\n<img src=\"http://i.imgur.com/UtD2T.png\">\r\n<br/>\r\nNote it is no longer binary as \"c\" had three connections\r\ntotal -- two children and one parent.\r\n\r\nEach node is represented as a vector, which always has at\r\nleast one element giving the name of the node as a symbol.\r\nSubsequent items in the vector represent the children of the\r\nnode.  Because the children are ordered it's important that\r\nthe tree you return keeps the children of each node in order\r\nand that the old parent node, if any, is appended on the\r\nright.\r\n\r\nYour function will be given two args -- the name of the node\r\nthat should become the new root, and the tree to transform.\r\n", "difficulty" : "Hard", "restricted" : null, "tags" : [ "tree" ], "tests" : [ "(= '(n)\r\n   (__ 'n '(n)))", "(= '(a (t (e)))\r\n   (__ 'a '(t (e) (a))))", "(= '(e (t (a)))\r\n   (__ 'e '(a (t (e)))))", "(= '(a (b (c)))\r\n   (__ 'a '(c (b (a)))))", "(= '(d \r\n      (b\r\n        (c)\r\n        (e)\r\n        (a \r\n          (f \r\n            (g) \r\n            (h)))))\r\n  (__ 'd '(a\r\n            (b \r\n              (c) \r\n              (d) \r\n              (e))\r\n            (f \r\n              (g)\r\n              (h)))))", "(= '(c \r\n      (d) \r\n      (e) \r\n      (b\r\n        (f \r\n          (g) \r\n          (h))\r\n        (a\r\n          (i\r\n          (j\r\n            (k)\r\n            (l))\r\n          (m\r\n            (n)\r\n            (o))))))\r\n   (__ 'c '(a\r\n             (b\r\n               (c\r\n                 (d)\r\n                 (e))\r\n               (f\r\n                 (g)\r\n                 (h)))\r\n             (i\r\n               (j\r\n                 (k)\r\n                 (l))\r\n               (m\r\n                 (n)\r\n                 (o))))))\r\n" ], "title" : "Tree reparenting", "user" : "chouser" },
          { "_id" : 131, "description" : "Given a variable number of sets of integers, create a function which returns true iff all of the sets have a non-empty subset with an equivalent summation.", "difficulty" : "Medium", "restricted" : null, "tags" : [ "math" ], "tests" : [ "(= true  (__ #{-1 1 99} \r\n             #{-2 2 888}\r\n             #{-3 3 7777})) ; ex. all sets have a subset which sums to zero", "(= false (__ #{1}\r\n             #{2}\r\n             #{3}\r\n             #{4}))", "(= true  (__ #{1}))", "(= false (__ #{1 -3 51 9} \r\n             #{0} \r\n             #{9 2 81 33}))", "(= true  (__ #{1 3 5}\r\n             #{9 11 4}\r\n             #{-3 12 3}\r\n             #{-3 4 -2 10}))", "(= false (__ #{-1 -2 -3 -4 -5 -6}\r\n             #{1 2 3 4 5 6 7 8 9}))", "(= true  (__ #{1 3 5 7}\r\n             #{2 4 6 8}))", "(= true  (__ #{-1 3 -5 7 -9 11 -13 15}\r\n             #{1 -3 5 -7 9 -11 13 -15}\r\n             #{1 -1 2 -2 4 -4 8 -8}))", "(= true  (__ #{-10 9 -8 7 -6 5 -4 3 -2 1}\r\n             #{10 -9 8 -7 6 -5 4 -3 2 -1}))" ], "title" : "Sum Some Set Subsets", "user" : "amcnamara" },
          { "_id" : 132, "description" : "Write a function that takes a two-argument predicate, a value, and a collection; and returns a new collection where the <code>value</code> is inserted between every two items that satisfy the predicate.", "difficulty" : "Medium", "restricted" : null, "tags" : [ "seqs", "core-functions" ], "tests" : [ "(= '(1 :less 6 :less 7 4 3) (__ < :less [1 6 7 4 3]))", "(= '(2) (__ > :more [2]))", "(= [0 1 :x 2 :x 3 :x 4]  (__ #(and (pos? %) (< % %2)) :x (range 5)))", "(empty? (__ > :more ()))", "(= [0 1 :same 1 2 3 :same 5 8 13 :same 21]\r\n   (take 12 (->> [0 1]\r\n                 (iterate (fn [[a b]] [b (+ a b)]))\r\n                 (map first) ; fibonacci numbers\r\n                 (__ (fn [a b] ; both even or both odd\r\n                       (= (mod a 2) (mod b 2)))\r\n                     :same))))" ], "title" : "Insert between two items", "user" : "srid" },
          { "_id" : 134, "description" : "Write a function which, given a key and map, returns true <a href=\"http://en.wikipedia.org/wiki/If_and_only_if\">iff</a> the map contains an entry with that key and its value is nil.", "difficulty" : "Elementary", "restricted" : null, "tags" : [ "maps" ], "tests" : [ "(true?  (__ :a {:a nil :b 2}))", "(false? (__ :b {:a nil :b 2}))", "(false? (__ :c {:a nil :b 2}))" ], "title" : "A nil key", "user" : "goranjovic" },
          { "_id" : 135, "description" : "Your friend Joe is always whining about Lisps using the prefix notation for math. Show him how you could easily write a function that does math using the infix notation. Is your favorite language that flexible, Joe?\r\n\r\nWrite a function that accepts a variable length mathematical expression consisting of numbers and the operations +, -, *, and /. Assume a simple calculator that does not do precedence and instead just calculates left to right.", "difficulty" : "Easy", "restricted" : null, "tags" : [ "higher-order-functions", "math" ], "tests" : [ "(= 7  (__ 2 + 5))", "(= 42 (__ 38 + 48 - 2 / 2))", "(= 8  (__ 10 / 2 - 1 * 2))", "(= 72 (__ 20 / 2 + 2 + 4 + 8 - 6 - 10 * 9))" ], "title" : "Infix Calculator", "user" : "fdaoud" },
          { "_id" : 137, "description" : "Write a function which returns a sequence of digits of a non-negative number (first argument) in numerical system with an arbitrary base (second argument). Digits should be represented with their integer values, e.g. 15 would be [1 5] in base 10, [1 1 1 1] in base 2 and [15] in base 16. ", "difficulty" : "Medium", "restricted" : null, "tags" : [ "math" ], "tests" : [ "(= [1 2 3 4 5 0 1] (__ 1234501 10))", "(= [0] (__ 0 11))", "(= [1 0 0 1] (__ 9 2))", "(= [1 0] (let [n (rand-int 100000)](__ n n)))", "(= [16 18 5 24 15 1] (__ Integer/MAX_VALUE 42))" ], "title" : "Digits and bases", "user" : "goranjovic" },
          { "_id" : 138, "description" : "Create a function of two integer arguments: the start and end, respectively.  You must create a vector of strings which renders a 45&deg; rotated square of integers which are successive squares from the start point up to and including the end point.  If a number comprises multiple digits, wrap them around the shape individually.  If there are not enough digits to complete the shape, fill in the rest with asterisk characters.  The direction of the drawing should be clockwise, starting from the center of the shape and working outwards, with the initial direction being down and to the right.", "difficulty" : "Hard", "restricted" : null, "tags" : [ "data-juggling" ], "tests" : [ "(= (__ 2 2) [\"2\"])", "(= (__ 2 4) [\" 2 \"\r\n             \"* 4\"\r\n             \" * \"])", "(= (__ 3 81) [\" 3 \"\r\n              \"1 9\"\r\n              \" 8 \"])", "(= (__ 4 20) [\" 4 \"\r\n              \"* 1\"\r\n              \" 6 \"])", "(= (__ 2 256) [\"  6  \"\r\n               \" 5 * \"\r\n               \"2 2 *\"\r\n               \" 6 4 \"\r\n               \"  1  \"])", "(= (__ 10 10000) [\"   0   \"\r\n                  \"  1 0  \"\r\n                  \" 0 1 0 \"\r\n                  \"* 0 0 0\"\r\n                  \" * 1 * \"\r\n                  \"  * *  \"\r\n                  \"   *   \"])" ], "title" : "Squares Squared", "user" : "amcnamara" },
          { "_id" : 140, "description" : "Create a function which accepts as input a boolean algebra function in the form of a set of sets, where the inner sets are collections of symbols corresponding to the input boolean variables which satisfy the function (the inputs of the inner sets are conjoint, and the sets themselves are disjoint... also known as canonical minterms).  Note:&nbsp;capitalized symbols represent truth, and lower-case symbols represent negation of the inputs.  Your function must return the minimal function which is logically equivalent to the input.\r\n</br></br>\r\nPS &mdash; You may want to give this a read before proceeding: <a href=\"http://en.wikipedia.org/wiki/K_map\">K-Maps</a>", "difficulty" : "Hard", "restricted" : null, "tags" : [ "math", "circuit-design" ], "tests" : [ "(= (__ #{#{'a 'B 'C 'd}\r\n         #{'A 'b 'c 'd}\r\n         #{'A 'b 'c 'D}\r\n         #{'A 'b 'C 'd}\r\n         #{'A 'b 'C 'D}\r\n         #{'A 'B 'c 'd}\r\n         #{'A 'B 'c 'D}\r\n         #{'A 'B 'C 'd}})\r\n   #{#{'A 'c} \r\n     #{'A 'b}\r\n     #{'B 'C 'd}})", "(= (__ #{#{'A 'B 'C 'D}\r\n         #{'A 'B 'C 'd}})\r\n   #{#{'A 'B 'C}})", "(= (__ #{#{'a 'b 'c 'd}\r\n         #{'a 'B 'c 'd}\r\n         #{'a 'b 'c 'D}\r\n         #{'a 'B 'c 'D}\r\n         #{'A 'B 'C 'd}\r\n         #{'A 'B 'C 'D}\r\n         #{'A 'b 'C 'd}\r\n         #{'A 'b 'C 'D}})\r\n   #{#{'a 'c}\r\n     #{'A 'C}})", "(= (__ #{#{'a 'b 'c} \r\n         #{'a 'B 'c}\r\n         #{'a 'b 'C}\r\n         #{'a 'B 'C}})\r\n   #{#{'a}})", "(= (__ #{#{'a 'B 'c 'd}\r\n         #{'A 'B 'c 'D}\r\n         #{'A 'b 'C 'D}\r\n         #{'a 'b 'c 'D}\r\n         #{'a 'B 'C 'D}\r\n         #{'A 'B 'C 'd}})\r\n   #{#{'a 'B 'c 'd}\r\n     #{'A 'B 'c 'D}\r\n     #{'A 'b 'C 'D}\r\n     #{'a 'b 'c 'D}\r\n     #{'a 'B 'C 'D}\r\n     #{'A 'B 'C 'd}})", "(= (__ #{#{'a 'b 'c 'd}\r\n         #{'a 'B 'c 'd}\r\n         #{'A 'B 'c 'd}\r\n         #{'a 'b 'c 'D}\r\n         #{'a 'B 'c 'D}\r\n         #{'A 'B 'c 'D}})\r\n   #{#{'a 'c}\r\n     #{'B 'c}})", "(= (__ #{#{'a 'B 'c 'd}\r\n         #{'A 'B 'c 'd}\r\n         #{'a 'b 'c 'D}\r\n         #{'a 'b 'C 'D}\r\n         #{'A 'b 'c 'D}\r\n         #{'A 'b 'C 'D}\r\n         #{'a 'B 'C 'd}\r\n         #{'A 'B 'C 'd}})\r\n   #{#{'B 'd}\r\n     #{'b 'D}})", "(= (__ #{#{'a 'b 'c 'd}\r\n         #{'A 'b 'c 'd}\r\n         #{'a 'B 'c 'D}\r\n         #{'A 'B 'c 'D}\r\n         #{'a 'B 'C 'D}\r\n         #{'A 'B 'C 'D}\r\n         #{'a 'b 'C 'd}\r\n         #{'A 'b 'C 'd}})\r\n   #{#{'B 'D}\r\n     #{'b 'd}})" ], "title" : "Veitch, Please!", "user" : "amcnamara" },
          { "_id" : 141, "description" : "<p>\r\n  In <a href=\"http://en.wikipedia.org/wiki/Trick-taking_game\">trick-taking\r\n  card games</a> such as bridge, spades, or hearts, cards are played\r\n  in groups known as \"tricks\" - each player plays a single card, in\r\n  order; the first player is said to \"lead\" to the trick. After all\r\n  players have played, one card is said to have \"won\" the trick. How\r\n  the winner is determined will vary by game, but generally the winner\r\n  is the highest card played <i>in the suit that was\r\n  led</i>. Sometimes (again varying by game), a particular suit will\r\n  be designated \"trump\", meaning that its cards are more powerful than\r\n  any others: if there is a trump suit, and any trumps are played,\r\n  then the highest trump wins regardless of what was led.\r\n</p>\r\n<p>\r\n  Your goal is to devise a function that can determine which of a\r\n  number of cards has won a trick. You should accept a trump suit, and\r\n  return a function <code>winner</code>. Winner will be called on a\r\n  sequence of cards, and should return the one which wins the\r\n  trick. Cards will be represented in the format returned\r\n  by <a href=\"/problem/128/\">Problem 128, Recognize Playing Cards</a>:\r\n  a hash-map of <code>:suit</code> and a\r\n  numeric <code>:rank</code>. Cards with a larger rank are stronger.\r\n</p>", "difficulty" : "Medium", "restricted" : null, "tags" : [ "game", "cards" ], "tests" : [ "(let [notrump (__ nil)]\r\n  (and (= {:suit :club :rank 9}  (notrump [{:suit :club :rank 4}\r\n                                           {:suit :club :rank 9}]))\r\n       (= {:suit :spade :rank 2} (notrump [{:suit :spade :rank 2}\r\n                                           {:suit :club :rank 10}]))))", "(= {:suit :club :rank 10} ((__ :club) [{:suit :spade :rank 2}\r\n                                       {:suit :club :rank 10}]))", "(= {:suit :heart :rank 8}\r\n   ((__ :heart) [{:suit :heart :rank 6} {:suit :heart :rank 8}\r\n                 {:suit :diamond :rank 10} {:suit :heart :rank 4}]))" ], "title" : "Tricky card games", "user" : "amalloy" },
          { "_id" : 143, "description" : "Create a function that computes the <a href=\"http://en.wikipedia.org/wiki/Dot_product#Definition\">dot product</a> of two sequences. You may assume that the vectors will have the same length.", "difficulty" : "Easy", "restricted" : null, "tags" : [ "seqs", "math" ], "tests" : [ "(= 0 (__ [0 1 0] [1 0 0]))", "(= 3 (__ [1 1 1] [1 1 1]))", "(= 32 (__ [1 2 3] [4 5 6]))", "(= 256 (__ [2 5 6] [100 10 1]))" ], "title" : "dot product", "user" : "bloop" },
          { "_id" : 144, "description" : "Write an oscillating iterate: a function that takes an initial value and a variable number of functions. It should return a lazy sequence of the functions applied to the value in order, restarting from the first function after it hits the end.", "difficulty" : "Medium", "restricted" : null, "tags" : [ "sequences" ], "tests" : [ "(= (take 3 (__ 3.14 int double)) [3.14 3 3.0])", "(= (take 5 (__ 3 #(- % 3) #(+ 5 %))) [3 0 5 2 7])", "(= (take 12 (__ 0 inc dec inc dec inc)) [0 1 0 1 0 1 2 1 2 1 2 3])\r\n" ], "title" : "Oscilrate", "user" : "bloop" },

This file has been truncated. show original

There’s also a known issue here stating that some of the problems are missing, including problem #130. It seems that this issue hasn’t been addressed yet, though.

tasx · October 24, 2024, 2:31pm

Question: Will adding 4clojure.com to the ignore file make the broken link in each track go away?

If not, another option would be to change the links to point to the new site, hoping that the issue will eventually be fixed. At least this way, we won’t be getting an error.

IsaacG · October 24, 2024, 3:07pm

If the link is dead, it should be dropped, not ignored.

I think any link ignore data is probably synced across tracks. That would make sense and the repos are set to in a sensible manner.

tasx · October 24, 2024, 3:18pm

I agree.

How about replacing 4clojure.com with a link to the 4ever-clojure repo, which does contain the original exercise in the JSON file I posted above? This way, the problem is essentially fixed.

Cool-Katt · October 24, 2024, 3:33pm

This seems like a good fix.

Alternatively, the actual exercise, or at least a copy of it, seems to still exist here, but I do think that replacing with the link to the repo is better.

Cool-Katt · October 24, 2024, 3:46pm