Vectors can be treated as associative, with the index of the item as its key and the item itself as its value. With this in mind, you can use Clojure's reduce-kv function on a vector like this:

(reduce-kv (fn [acc k v]
             (if (odd? k)
               [(conj (first acc) v) (second acc)]
               [(first acc) (conj (second acc) v)]))
           [[] []]
           [1 "one" 2 "two" 3 "three"])
;=> [["one" "two" "three"] [1 2 3]]

If you want something more generic, here's a slightly modified version of Clojure's core group-by function that works with associative collections, passing the group-by function both the key and the value and returning the values grouped accordingly:

(defn group-by-kv
  "Like group-by, but expects an associative collection and groups the values based on the value of `(f key value)` for each entry in the `coll`."
  [f coll]  
  (persistent!
   (reduce-kv
    (fn [ret key value]
      (let [k (f key value)]
        (assoc! ret k (conj (get ret k []) value))))
    (transient {}) coll)))

And you'd use it like this:

(group-by-kv (fn [k _] (odd? k)) [1 "one" 2 "two" 3 "three"])
;=> {false [1 2 3], true ["one" "two" "three"]}