Comparing each neighboring pairs in clojure vector

Use partition to transform the vector to a sequence of consecutive pairs. Then use keep-indexed to add an index and filter them:

(defn indices< [xs]
  (keep-indexed (fn [i ys]
                  (when (apply < ys) i))
                (partition 2 1 xs)))

(indices< [1 1 2 2 1 2]) ;; => (1 4)

To find just the last such index, use last on this result. While it is possible to use reverse on the input, it does not offer any performance benefit for this problem.

The logic of forming pairs of numbers and comparing each number to the next number in the sequence can be factored out in a transducer that does not care about whether you want your result in the form of a vector with all indices or just the last index. Forming pairs can be done using partition as already suggested in the other answers, but I did not find a transducer implementation of that function, which would greatly facilitate. Here is a workaround that uses a mapping transducer along with some mutable state.

(defn indexed-pairs []
  (let [s (atom [-2 nil nil])]
    (comp (map #(swap! s (fn [[i a b]] [(inc i) b %])))
          (remove (comp neg? first)))))

(defn indices-of-pairs-such-that [f]
  (comp (indexed-pairs)
        (filter (fn [[i a b]] (f a b)))
        (map first)))

In this code, the function indices-of-pairs-such-that will return a transducer that we can use in various ways, for instance with into to produce a vector of indices:

(into [] (indices-of-pairs-such-that <) [1 1 2 2 1 2])
;; => [1 4]

Or, as was asked in the question, we can use tranduce along with a reducing function that always picks the second argument if we only want the last index:

(transduce (indices-of-pairs-such-that <) (completing (fn [a b] b)) nil [1 1 2 2 1 2])
;; => 4

This is the power of transducers: they decouple sequence algorithms from the results of those algorithms. The function indices-of-pairs-such-that encodes the sequence algorithm but does not have to know whether we want all the indices or just the last index.

The general problem can be solved with ...

(defn indexes-of-pairs [p coll]
  (let [check-list (map (fn [i x rx] (when (p x rx) i)) (range) coll (rest coll))]
    (filter identity check-list)))

... which returns the indexes of adjacent pairs of a sequence coll that are related by predicate p. For example,

(indexes-of-pairs < [1 1 2 2 1 2])
=> (1 4)

For your example, you can define

(def with-keep-indexed (partial indexes-of-pairs <))

Then

(with-keep-indexed [1 1 2 2 1 2])
=> (1 4)

There are many ways to solve a problem. Here are two alternatives, including a unit test using my favorite template project. The first one uses a loop over the first (N-1) indexes in an imperative style not so different than what you'd write in Java:

(ns tst.demo.core
  (:use tupelo.core tupelo.test))

(defn step-up-index-loopy
  [xs]    ; a sequence of "x" values
  (let-spy
    [xs    (vec xs) ; coerce to vector in case we get a list (faster)
     accum (atom []) ; an accumulator
     N     (count xs)]
    (dotimes [i (dec N)] ; loop starting at i=0
      (let-spy [j    (inc i)
                ival (get xs i)
                jval (get xs j)]
        (when (< ival jval)
          (swap! accum conj i))))
    @accum))

When run, it produces this output:

calling step-up-index-loopy
xs => [1 1 2 2 1 2]
accum => #object[clojure.lang.Atom 0x4e4dcf7c {:status :ready, :val []}]
N => 6
j => 1
ival => 1
jval => 1
j => 2
ival => 1
jval => 2
j => 3
ival => 2
jval => 2
j => 4
ival => 2
jval => 1
j => 5
ival => 1
jval => 2

The second one uses a more "functional" style that avoids direct indexing. Sometimes this makes things simpler, but sometimes it can appear more complicated. You be the judge:

(defn step-up-index
  [xs]    ; a sequence of "x" values
  (let-spy-pretty
    [pairs         (partition 2 1 xs)
     pairs-indexed (indexed pairs) ; append index # [0 1 2 ...] to beginning of each pair
     reducer-fn    (fn [accum pair-indexed]
                     ; destructure `pair-indexed`
                     (let-spy [[idx [ival jval]] pair-indexed]
                       (if (< ival jval)
                         (conj accum idx)
                         accum)))
     result        (reduce reducer-fn
                     [] ; initial state for `accum`
                     pairs-indexed)]
    result))

The function indexed is from the Tupelo Clojure library. When you run the code you'll see:

calling step-up-index
pairs => 
((1 1) (1 2) (2 2) (2 1) (1 2))
pairs-indexed => 
([0 (1 1)] [1 (1 2)] [2 (2 2)] [3 (2 1)] [4 (1 2)])
reducer-fn => 
#object[tst.demo.core$step_up_index$reducer_fn__21389 0x108aaf1f "tst.demo.core$step_up_index$reducer_fn__21389@108aaf1f"]
[idx [ival jval]] => [0 [1 1]]
[idx [ival jval]] => [1 [1 2]]
[idx [ival jval]] => [2 [2 2]]
[idx [ival jval]] => [3 [2 1]]
[idx [ival jval]] => [4 [1 2]]
result => 
[1 4]

Both of them work:

(dotest
  (newline)
  (println "calling step-up-index-loopy")
  (is= [1 4]
    (step-up-index-loopy [1 1 2 2 1 2]))
  (newline)
  (println "calling step-up-index")
  (is= [1 4]
    (step-up-index [1 1 2 2 1 2])))

With results:

-----------------------------------
   Clojure 1.10.3    Java 15.0.2
-----------------------------------

Testing tst.demo.core

Ran 2 tests containing 2 assertions.
0 failures, 0 errors.

The form let-spy is from the Tupelo Clojure library, and makes writing & debugging things easier. See the docs for more info. When satisfied everything is working, replace with

let-spy => let

Also be sure to study the list of documentation sources included in the template project, especially the Clojure CheatSheet.

Another solution using keep-indexed is pretty short:

(defn step-up-index
  [xs]
  (let [pairs  (partition 2 1 xs)
        result (vec
                 (keep-indexed
                   (fn [idx pair]
                     (let [[ival jval] pair]
                       (when (< ival jval)
                         idx)))
                   pairs))]
    result))

(dotest
  (is= [1 4] (step-up-index [1 1 2 2 1 2])))