user=> (time (problem-39))
"Elapsed time: 13560.903292 msecs"

might look cleaner with some ->> in there...

I feel it does

(defn problem-39 []
  (->> (let [my-map {}]
         (apply (partial merge-with set/union my-map)
                (for [a (range 1 1000)
                      b (range 1 1000)
                      c (range 1 1000)
                      :when (and (= (* a a) (+ (* b b) (* c c))) ; could be its own function
                                 (<= (+ a b c) 1000))
                      :let [sum (+ a b c)]]
                  {sum #{(sort (list a b c))}})))
       (map #(vector (first %) (count (second %))))
       (apply max-key second)
       (first)))

you could remove one of the for bindings and just compute the value for it, rather than checking all the possibilities

oh... dang of course. how I didn't think about it. TY so much Bob!!!

let me know if you see any other issue with the style or what I'm doing, I'm still a fairly early writer of code in clojure, even if I have been reading some for many years.

I think I might also bind b to (range a 1000), and that should make it such that none of the triples would be checked more than once, which would eliminate the need for sets and/or sorting. And then, frequencies is quite a useful function that could come in handy here, especially if the for just returns the sum (because if the triples don't overlap, then the values of a, b, and c aren't really needed any longer).

Ok that's where I'm at from your great advices:

(defn right-triangle? [a b p]
   (let [c (- p a b)]
     (= (* c c) (+ (* a a) (* b b)))))

 (defn problem-39 []
   (->> (frequencies
         (for [perimeter (range 12 1001)
               a (range 2 perimeter)
               b (range a (- perimeter a))
               :when (right-triangle? a b perimeter)]
           perimeter))
   (apply max-key second)
   (first)))

no question, much better, lot simpler.

also renaming sum to perimeter makes more sense >_< and iterating through the perimeter makes it much faster: 2s vs ~13

user=> (time (problem-39))
"Elapsed time: 2153.018042 msecs"
840

Thank you so very much for your help! I think I'm happy with that code now 🙂

let me know if you see any improvement or such that I could be missing at this point.

I did something pretty similar:

(->> (for [a (range 1 1000)
           b (range a 1000)
           :let [c   (math/sqrt (+ (* a a) (* b b)))
                 sum (+ a b (int c))]
           :when (and (zero? (mod c 1)) ; is c a whole number? 
                   (<= sum 1000))]
       sum)
  frequencies
  (apply max-key second)
  first)

oh I like that method to test if c is a whole number. I'll remember that.

If you mean like embedding them, that’s not possible

(defn transform [source] ;; <- arglist goes here
  (reduce-kv 
   (fn [m k v]
     (apply merge 
      (for [val v]
        (assoc m (str/lower-case val) k)))) {} source))

:woman-shrugging: took me more time than I wanted to come up with a solution (like 45min/1h) and a lot of try and fail in the repl... still loving so much this language :smiling_face_with_3_hearts:

here is another solution, maybe a little bit more incremental to build

(defn transform [source]
  (let [m (->> source
               (mapv (fn [[n v]] (zipmap v (repeat n))))
               (reduce merge))]
    (update-keys m String/.toLowerCase)))

it is using String/.toLowerCase which needs Clojure 1.12, but you can replace it with your str/lower-case

with more incremental I mean you can start with :

(->> {1 ["APPLE" "ARTICHOKE"], 2 ["BOAT" "BALLERINA"]}
     (mapv (fn [[n v]] (zipmap v (repeat n)))))

[{"APPLE" 1, "ARTICHOKE" 1} {"BOAT" 2, "BALLERINA" 2}]

Oh I didn't know about update-keys... nice one. Curious on when to use String/.toLowerCase vs str/lower-case in general I'm not yet super familiar with zipmap, gonna read the doc now.

yeah, there is update-keys and update-vals, pretty useful

oh! I was looking for something like that earlier. (zipmap)... cool

regarding the lowerCase, since strings in Clojure are java.lang.String you can call the .toLowerCase method on them, without any extra ns require

so create a map from a collection of keys and collection of values with the lowest size of both.

exactly

I see that makes sense.

Thank you so very much it's super helpful to see other solutions. Do you think anything was wrong or not readable in my solution? I'm really trying to be good at writing understandable clojure.

I like your solution... It's probably what I wanted to do at first, but didn't find another solution that what I did.

I really like the fact you've used threading.

Do you think anything was wrong or not readable in my solution? I'm really trying to be good at writing understandable clojure.I don't think there is anything wrong. Going the reduce way you can also do :

(defn transform [source]
  (reduce-kv 
   (fn [m k v]
     (reduce (fn [mm val]
               (assoc mm (str/lower-case val) k))
             m
             v))
   {}
   source))

it think that is also a common pattern, where the inner reduce starts with the "accumulator so far"

using a transducer

(let [data {1 ["APPLE" "ARTICHOKE"], 2 ["BOAT" "BALLERINA"]}]
  (into {} (mapcat (fn [[k vs]] (map (fn [v] [(str/lower-case v) k]) vs))) data))

Yeah transducers are still beyond my current level

It does look super clean that way tho...

ok so you're basically composing two map (one being a mapcat)

I need to get to the level where this would be natural to me. I don't think I could have come up with that one.

(let [data {1 ["APPLE" "ARTICHOKE"], 2 ["BOAT" "BALLERINA"]}
      xtrans (mapcat
              (fn [[k vs]]
                (map (fn [v] [(str/lower-case v) k]) vs)))]
  (into {} xtrans data))

it's still not natural to me 😄 just figured it would be a good way to do it there that wasn't shown yet

I think I start getting transducer... I understand it's about composing the transformations... But I haven't practice or try it yet.

Like most functions without the collection parameter returns a transducers, so we can compose them, and only pass the collection in the end... Is that the idea?

I did watch the various video about it... but it still a bit fuzzy to me.

it's good to see one example on an exercise I tried to solve. Thank you so very much Nazral!

That's only one transducer there though, not being composed. You could probably make a very similar definition but that isn't a transducer, if you wanted to keep things simpler

I'm afk rn but I'd probably end up doing a mix between @U0739PUFQ's and @UGH9KH1DF's

This is the default code with one change suggested by the tutorial in the namespace

(:require [play-clj.core :refer :all]
            [play-clj.g2d :refer :all]))

(defscreen main-screen
  :on-show
  (fn [screen entities]
    (update! screen :renderer (stage))
    (label "Hello world!" (color :white)))
  
  :on-render
  (fn [screen entities]
    (clear!)
    (render! screen entities)))

(defgame hello-world-game
  :on-create
  (fn [this]
    (set-screen! this main-screen)))

My guess was to replace entities here in the :on-render

(render! screen entities)))

(label ...)is where the label entity is being created

Thank you!