Как я могу умножить все элементы в одной коллекции со всеми элементами в другой коллекции?

Скажем, у меня есть:

(def s1 [1 2 3 4 5])
(def s2 [1 2 3 4 5])

Для каждого x в s1, я хочу умножить его с каждым y в s2.


Чтобы прояснить, я в основном хочу декартово произведение, поэтому я не думаю, что map работает здесь.

Ответы

Ответ 1

(for [x1 s1
      x2 s2]
  (* x1 x2))

Ответ 2

В то время как решение с использованием для лучше, вот карта - только версия, если у вас есть проблемы с пониманием для:

(map #(map (partial * %) s2) s1)

для выше расширяется до чего-то подобного, за исключением того, что вместо partial будет использоваться другая анонимная функция, например:

(map (fn [x] (map (fn [y] (* x y)) s2)) s1)

или, аккуратно сформированный:

(map
  (fn [x]
    (map
      (fn [y]
        (* x y))
      s2))
  s1)

Ответ 3

Вот java 1.5 (или более новый) эквивалент кода Михала:

List<Integer> numbers = new ArrayList<Integer>();    

for(int x1 : s1) {
  for(int x2 : s2) {
    numbers.add(x1 * x2);
  }
}

Отличие состоит в том, что for петли в java не возвращают последовательность, как это происходит в clojure, поэтому вам нужно использовать изменяемый ArrayList для построения результата.

Определенно не так красиво, как версия clojure, но намного лучше, чем вы могли бы сделать в Java 1.4.

Ответ 4

Простая визуальная демонстрация основных функций for:

user=> (pprint 
         (for [tens (range 10) 
               ones (range 10)]
           [tens ones]))
([0 0]
 [0 1]
 [0 2]
 [0 3]
 [0 4]
 [0 5]
 [0 6]
 [0 7]
 [0 8]
 [0 9]
 [1 0]
 [1 1]
 [1 2]
 [1 3]
 [1 4]
 [1 5]
 [1 6]
 [1 7]
 [1 8]
 [1 9]
 [2 0]
 [2 1]
 [2 2]
 [2 3]
 [2 4]
 [2 5]
 [2 6]
 [2 7]
 [2 8]
 [2 9]
 [3 0]
 [3 1]
 [3 2]
 [3 3]
 [3 4]
 [3 5]
 [3 6]
 [3 7]
 [3 8]
 [3 9]
 [4 0]
 [4 1]
 [4 2]
 [4 3]
 [4 4]
 [4 5]
 [4 6]
 [4 7]
 [4 8]
 [4 9]
 [5 0]
 [5 1]
 [5 2]
 [5 3]
 [5 4]
 [5 5]
 [5 6]
 [5 7]
 [5 8]
 [5 9]
 [6 0]
 [6 1]
 [6 2]
 [6 3]
 [6 4]
 [6 5]
 [6 6]
 [6 7]
 [6 8]
 [6 9]
 [7 0]
 [7 1]
 [7 2]
 [7 3]
 [7 4]
 [7 5]
 [7 6]
 [7 7]
 [7 8]
 [7 9]
 [8 0]
 [8 1]
 [8 2]
 [8 3]
 [8 4]
 [8 5]
 [8 6]
 [8 7]
 [8 8]
 [8 9]
 [9 0]
 [9 1]
 [9 2]
 [9 3]
 [9 4]
 [9 5]
 [9 6]
 [9 7]
 [9 8]
 [9 9])

Ответ 5

Проще, чем это возможно:

(map * '(1 2) '(3 4))

даст:

(3 8)