desafio.md

Função promover/rebaixar (parte 1)

Dado uma coleção coll, por exemplo, [:a :b :c :d :e] e um predicado pred, por exemplo #{:c}, implementar uma função promover que recebe (promover #{:c} [:a :b :c :d :e]) e retorna a coleção com o elemento selecionado "uma posição a frente": [:a :c :b :d :e]

Implementar também a função rebaixar, com a mesma assinatura, porém resulta em [:a :b :d :c :e]

Os casos de borda (elementos repetidos, agrupamentos degenerados) não são importantes.

O unico caso de teste realmente necessário é o descrito no enumciado:

• o pred só irá bater em um elemento
• o elemento não estará em nenhuma das extremidades da lista

EXTRA

Fazer uma função promover+rebaixar genérica, onde o pred retorna um int? que indica quantas posições o elemento será promovido/rebaixado.

(defn promover
  [pred els]
  (let [els (vec els)]
    (sequence (comp (map-indexed (fn [idx el]
                                   (let [nx (get els (inc idx))]
                                     (cond
                                       (pred nx) [nx el]
                                       (pred el) []
                                       :else [el]))))
                    cat)
              els)))

(defn rebaixar
  [pred els]
  (let [els (vec els)]
    (sequence (comp (map-indexed (fn [idx el]
                                   (let [prev (get els (dec idx))]
                                     (cond
                                       (pred prev) [el prev]
                                       (pred el) []
                                       :else [el]))))
                    cat)
              els)))

(defn rebaixar [steps pred coll]
  (let [[before [selected & after]] (split-with (complement pred) coll)
        [mid end] (split-at steps after)]
    (concat before mid (conj end selected))))

(defn promover [steps pred coll] (->> coll reverse (rebaixar steps pred) reverse))

Uma versao que nao requer recriar as listas inteiras:

(defn swap-vec-indexes [v ia ib]
  (-> v
      (assoc ia (get v ib))
      (assoc ib (get v ia))))

(defn promover [pred coll]
  (let [item-idx (some (fn [[item n]]
                         (if (pred item)
                           n)) (map vector coll (range)))]
    (if (some-> item-idx pos?)
      (swap-vec-indexes coll (dec item-idx) item-idx)
      coll)))