clojure - Split 100% in a given number of columns width random width

Question

i want to split 100% in a given number of columns. but the width of the columns should be random. here is my first try. but it's static to 5 columns. any ideas to make it dynamic?

(defn create-columns []

  (let [col1 (int (random/number 14 26))
        col2 (int (random/number 14 26))
        col3 (int (random/number 14 26))
        col4 (int (random/number 14 26))
        col5 (- 100 (+ col1 col2 col3 col4))]

    [{:width col1, :left 0}
     {:width col2, :left (int col1)}
     {:width col3, :left (+ col1 col2)}
     {:width col4, :left (+ col1 col2 col3)}
     {:width col5, :left (+ col1 col2 col3 col4)}]))

result should be like

[{:width 23, :left 0} {:width 24, :left 23} {:width 23, :left 47} {:width 14, :left 70} {:width 16, :left 84}]

and ideas?

question from:https://stackoverflow.com/questions/65892066/split-100-in-a-given-number-of-columns-width-random-width

Answer 1

Here is an algorithm expressed as operations on lazy sequences:

1. Generate random positions separating the columns including bounds to the left and right.
2. Sort all the positions
3. Form pairs of every position and the next one
4. Map the pairs to maps with :left and :width.

Here's the code doing that.

(defn random-cols [total col-count]
  (->> #(rand-int (inc total))
       (repeatedly (dec col-count))
       (into [0 total])
       sort
       (partition 2 1)
       (map (fn [[left right]] {:left left :width (- right left)}))))

(random-cols 100 3)
;; => ({:left 0, :width 21} {:left 21, :width 24} {:left 45, :width 55})

This can generate columns that have a width as small as 0, but constraining the columns to some minimum width is likely something you might want to do although the question does not say anything about that:

(defn random-cols-constrained [total col-count min-width]
  (let [widths (map #(+ min-width (:width %))
                    (random-cols (- total (* col-count min-width))
                                 col-count))]
    (map (fn [w l] {:width w :left l})
         widths
         (reductions + 0 widths))))