Clojure; এন = 1, 2 এর জন্য অসাম্য আকারের তালিকাগুলির তালিকা থেকে সমস্ত এনথ উপাদান নির্বাচন করুন।

আমি একটি ফাংশন চাই, যেমন,

(f '([1 4 7] [2 5 9] [3 6]))

দিতে হবে

([1 2 3] [4 5 6] [7 9])

আমি চেষ্টা করেছিলাম

(apply map vector '([1 4 7] [2 5 9] [3 6]))

শুধুমাত্র উত্পাদন করবে:

([1 2 3] [4 5 6])

আমার প্রয়োজনীয়তাগুলি বর্ণনা করা আমার পক্ষে কঠিন যে আমার কাছে একটি সমাধান তৈরি করা কঠিন।

আমার সমাধান, অথবা একটি সমাধান করার পয়েন্টার উন্নত করতে আমাকে সাহায্য করুন।

আগাম ধন্যবাদ!

1

7 উত্তর

অথবা লুপ/​​পুনরাবৃত্তি সঙ্গে এই ভাবে:

user> (defn transpose-all-2 [colls]
        (loop [colls colls res []]
          (if-let [colls (seq (filter seq colls))]
            (recur (doall (map next colls)) 
                   (conj res (mapv first colls)))
            res)))
#'user/transpose-all-2

user> (transpose-all-2 x)
[[1 2 3] [4 5 6] [7 9]]

user> (transpose-all-2 '((0 1 2 3) (4 5 6 7) (8 9)))
[[0 4 8] [1 5 9] [2 6] [3 7]]
3
যোগ

আমি আরো সাধারণ সমস্যা সমাধান করব যার মানে আপনি ভবিষ্যতে সেই ফাংশনটি পুনরায় ব্যবহার করতে পারেন। আমি মানচিত্র পরিবর্তন করব যাতে এটি ক্ষুদ্রতম মানচিত্রের বাইরে চলে যায়।

(defn map-all
  "Like map but if given multiple collections will call the function f
   with as many arguments as there are elements still left."
  ([f] (map f))
  ([f coll] (map f coll))
  ([f c1 & colls]
   (let [step (fn step [cs]
                (lazy-seq
                  (let [ss (keep seq cs)]
                    (when (seq ss)
                      (cons (map first ss)
                            (step (map rest ss)))))))]
     (map #(apply f %) (step (conj colls c1))))))


(apply map-all vector '([1 4 7] [2 5 9] [3 6]))
(apply map-all vector '([1 false 7] [nil 5 9] [3 6] [8]))

দ্রষ্টব্য, যেটি অন্য অনেক সমাধানগুলির বিরোধিতা করে, এই ক্রমের মধ্যে nil বা false থাকা সত্ত্বেও এটি একটি ভাল কাজ করে।

3
যোগ
প্রকৃতপক্ষে, সবচেয়ে সাধারণ সমাধান! ধন্যবাদ।
যোগ লেখক Yu Shen, উৎস
আমি মানচিত্র পরিবর্তন করব যাতে এটি সমস্ত চলমান আর্গুমেন্টগুলি শেষ না হওয়া পর্যন্ত চলতে থাকে।
যোগ লেখক Thumbnail, উৎস

আপনি যদি সময়ের আগে ভেক্টর সর্বাধিক দৈর্ঘ্য জানেন, আপনি সংজ্ঞায়িত করতে পারে

(defn tx [colls] 
  (lazy-seq 
    (cons (filterv identity (map first colls))
          (tx (map rest colls))))) 

তারপর

(take 3 (tx '([1 4 7] [2 5 9] [3 6])))
2
যোগ
অলস সিক ব্যবহার করে খুব চতুর সমাধান!
যোগ লেখক Yu Shen, উৎস
আপনি কাজ করতে পারেন এবং ভেক্টরগুলির সর্বাধিক দৈর্ঘ্য ব্যবহার করতে পারেন ( def def [colls] (গ্রহণ করুন (সর্বোচ্চ ম্যাপ গণনা কল)) (tx colls)) । তারপর (ty '([1 4 7] [2 5 9] [3 6])) ([1 2 3] [4 5 6] [7 9]) তৈরি করে </কোড>।
যোগ লেখক Thumbnail, উৎস
@ ক্লোজুরঃ আপনি nil এবং false এবং প্রথম s এর পরিবর্তে ক্রমিক ফিল্টার করে nil মানগুলির প্রায়শ্চিত্তটি মুছে ফেলতে পারেন। (tx def [ colls] (অলস seq (consi (মানচিত্র প্রথম (seq colls রাখা)) (Tx (মানচিত্র বিশ্রাম colls)))) </কোড>
যোগ লেখক Thumbnail, উৎস
মনে রাখবেন যে এটি ক্রম অনুসারে nil এবং false ফিল্টার করে।
যোগ লেখক ClojureMostly, উৎস

এখানে আমার নিজের প্রচেষ্টা:

(defn f [l]
  (let [max-count (apply max (map count l))
        l-patched (map (fn [e] (if (< (count e) max-count)
                                 (concat e (take (- max-count (count e)) (repeat nil)))
                                 e)) l)]
    (map (fn [x] (filter identity x)) (apply map vector l-patched))
    )) 
0
যোগ

একটি সহজ সমাধান হয়

(defn transpose-all
  [colls]
  (lazy-seq
   (let [ss (keep seq colls)]
     (when (seq ss)
       (cons (map first ss) (transpose-all (map rest ss)))))))

উদাহরণ স্বরূপ,

(transpose-all '([1 4 7] [2 5 9] [3 6] [11 12 13 14]))
;((1 2 3 11) (4 5 6 12) (7 9 13) (14))
0
যোগ

এখানে অন্য একটি যান যা আপনাকে ভেক্টর দৈর্ঘ্য অগ্রিম জানতে হবে না:

(defn padzip [& [colls]]
    (loop [acc [] colls colls]
      (if (every? empty? colls) acc
          (recur (conj acc (filterv some? 
                                    (map first colls))) (map rest colls)))))
0
যোগ
ধন্যবাদ, @ থাম্বনেল! আমি এখনও একটি শিক্ষানবিশ।
যোগ লেখক Turn, উৎস

আরেকটি সহজ সমাধান:

(->> jagged-list
     (map #(concat % (repeat nil)))
     (apply map vector)
     (take-while (partial some identity)))

এই মত একটি জাগ্রত তালিকা

'([1   4   7     ] 
  [2   5   9     ] 
  [3   6         ] 
  [11  12  13  14]) 

উত্পাদন করবে:

'([1   2   3   11] 
  [4   5   6   12] 
  [7   9   nil 13] 
  [nil nil nil 14])
0
যোগ