지도의 벡터에서 가장 큰 키의 벡터를 얻는 것은

Question

I는 다음과 같습니다지도의 벡터를 가지고 :

(def game-vec [{:game 1 :start 123456} 
     {:game 2 :start 523456} 
     {:game 3 :start 173456} 
     {:game 1 :start 123456} 
     {:game 1 :start 523456} 
     {:game 2 :start 128456} 
     {:game 3 :start 123256}]) 

나는 각 :game 가장 큰 :start 시간이 걸릴 싶습니다. 이 작업을 수행하는 가장 좋은 방법은 무엇입니까?

Answer 1

또 다른 솔루션입니다

user=> (map #(apply max-key :start %) 
      (vals (group-by :game game-vec))) 
({:game 1, :start 523456} 
{:game 2, :start 523456} 
{:game 3, :start 173456}) 

Answer 2

한 가지 방법은 벡터에서 모든 게임을 얻는 것입니다.

어쩌면 같은 것을 :

(defn game-keys [from] 
    (set (map (fn [x] (:game x)) from))) 

이제 우리는 모두 독특한 게임 그 각각에 대해 지금 어딘가에 저장 한 우리는 시작의 가장 높은 값을합니다. 정렬은 우리가 올바른 게임을 걸러 낼 때 유용 할 수 있습니다.

(map (fn [x] (max-start (games x game-vec))) (game-keys game-vec)) 

를 그 하나에 불과하지만 :

(defn games [key from] 
    (filter (fn [x] (= (:game x) key)) from)) 

그래서 우리는 지금 우리는 지금 우리가 할 수있는

(defn max-start [lst] 
    (first (sort (fn [x y] (> (:start x) (:start y))) lst))) 

그래서 그들 중 가장 높은 필요, 우리가 원하는 게임을 얻을 수 있습니다 최선의 정의에 따라 더 나은 방법이있을 수 있습니다.

Answer 3

마지막 해결책을 통해 @nickik의 최대 기능 아이디어로 반복합니다. 여기에 한 줄 어딘가에

(reduce                                                          
(fn [m x]                                                         
    (assoc m (:game x)                                                      
      (max (:start x)                                                     
       (or (m (:game x)) 0))))                                                  
{} 
game-vec) 

Answer 4

:-) 나는이 함께했다 나는 확신이 :

(defn max-start-per-game [coll] 
     (into {} (map (fn [[k v]] [k (apply max (map :start v))]) 
         (group-by :game game-vec)))) 

=> (max-start-per-game game-vec) 
{1 523456, 2 523456, 3 173456} 

아이디어는 한 곳에서 경기당 모든 데이터를 얻을 것입니다 시작을 위해 데이터를 꺼내십시오. 그런 다음 최대한 활용하십시오.

더 많은 일반 버전 :

(defn collect [coll sum-key collect] 
    (into {} (map (fn [[k v]] [k (map :start v)]) 
       (group-by :game game-vec)))) 

(defn no-good-name 
    [coll f key1 key2] 
    (into {} (map (fn [[k v]] [k (f v)]) 
       (collect coll key1 key2))) 


(no-good-name game-veC#(apply max %) :game :start) 
=> {1 523456, 2 523456, 3 173456} 

(맵의 모든 값을 통해 매핑 fmap 함수 어딘가에있는 contrib에서라는 costum 기능()를 사용하여이 probebly 더 나은 것입니다하지만 당신은 당신의 자기 것을 할 수있는)

Answer 5

(into {} (for [[game times] (group-by :game game-vec)] 
      {game (apply max (map :start times))})) 

Answer 6

기능적으로 매우 줄리안 Chastang의 코드와 유사하고 reduce를 사용하여 내가 가진 :

(defn max-start-per-game [games] 
    (reduce (fn [res {:keys [game start]}] 
    (let [cur-start (get res game 0) 
      max-start (max start cur-start)] 
     (assoc res game max-start))) 
    {} 
    games))

 
user=> (max-start-per-game game-vec) 
{3 173456, 2 523456, 1 523456}

,

group-by을 사용하거나 amalloy의 코드는 가능한 간결합니다.

다음