326 - PurelyFunctional.tv Newsletter - Puzzle https://purelyfunctional.tv/issues/purelyfunctional-tv-newsletter-326-tip-consult-the-repl/

00 Maximum Concatenation.md

Largest integer from concatenation

If I have a list of integers, I can concatenate their base-10 strings to get one large integer. However, if I reorder them, then concatenate them, I could get a larger integer. The task here is to find the largest integer you can create by concatenating a given set of integers.

Here are some test cases:

(maxcat [1 2 3 4 5 6 7 8 9]) ;=> 987654321
(maxcat [12 34 56 199])      ;=> 563419912

Andreas Werner.clj

(defn maxcat [s]
  (when (seq s)
    (->> (map str s)
      (sort (comp - compare))
      (apply str)
      (java.math.BigInteger.))))

Andrew Whitehouse.clj

(defn maxcat [coll]
  (->> coll (map str) sort reverse (apply str)))

(maxcat [1 2 3 4 5 6 7 8 9]) ;=> 987654321
(maxcat [12 34 56 199])      ;=> 563419912

Brad Collins.clj

(ns maxcat.core
  (:require [clojure.string :as str]))

(defn maxcat [ns]
  (->> ns
    (map str)
    (sort #(compare %2 %1))
    (str/join)
    (Long/parseLong)))


(ns maxcat.core-test
  (:require [clojure.test :refer :all]
            [maxcat.core :refer :all]))

(deftest test-maxcat
  (testing "(maxcat [1 2 3 4 5 6 7 8 9]) = 987654321"
    (is (= (maxcat [1 2 3 4 5 6 7 8 9]) 987654321)))
  (testing "(maxcat [12 34 56 199]) = 563419912"
    (is (= (maxcat [12 34 56 199]) 563419912))))

Lindsay Davies.clj

(defn maxcat [xs] (->> xs (map str) sort reverse (clojure.string/join "") (Long/valueOf)))

Mark Champine.clj

(defn maxcat
  "Return largest integer that can be created by concatenating
  a collection of integers v in any order."
  [v]
  (->> v
       (sort
        (fn [x y]
          (compare
           (read-string (str y x)) (read-string (str x y)))))
       (apply str)
       read-string))

Maxim Nicolaevich.clj

(defn maxcat [nums]
  (if (= 0 (count nums))
    []
    (->> nums
         (map str)
         sort
         reverse
         (string/join "")
         (Integer.))))

Neil McCallum.clj

(defn maxcat
  "find the biggest int avaliable by concatenation of the elements in coll"
  [coll]
  (->> coll
      (map str)
      sort
      reverse
      clojure.string/join
      BigInteger.))

Steven Proctor.clj

(defn maxcat [l] (->> l (sort-by str) reverse (clojure.string/join "") bigint))

Valentin Waeselynck.clj

(defn non-negative-integer?
  [i]
  (and
    (integer? i)
    (not (neg? i))))

(defn maxcat [is]
  {:pre [(seqable? is)
         (not (empty? is))
         (every? non-negative-integer? is)]}
  (->> is
    (mapv #(Long/toString % 10))
    (sort (fn compare-base10 [s1 s2]
            (compare
              (Long/parseLong (str s2 s1) 10)
              (Long/parseLong (str s1 s2) 10))))
    (apply str)
    (read-string)))

(Note: my solution isn't the only one that doesn't fail on [90 9], Mark Champine's works exactly the same way.)

Thanks, Val. I was wrong.