[Clojure] Code Style + Einfachere Lösung?

[mvitz]

Hallo zusammen,

evtl. programmiert hier ja auch jemand in Clojure. Ich habe gerade Problem Nummer 1 von projecteuler.net in Clojure gelöst und würde nun gerne wissen, ob die Lösung auch eleganter geht, bzw. ob der Coding Style so üblich ist oder nicht.

Edit:
Die Aufgabenstellung lautet:

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.

Find the sum of all the multiples of 3 or 5 below 1000.

(def sum 0)
(doseq [i (range 1000)]
	(def sum
		(+ sum
			(if (= 0 (rem i 3)) i
				(if (= 0 (rem i 5)) i 0)))))
(print sum)

 

[Landei]

Keine Ahnung von Clujure, aber die beiden ifs lassen sich bestimmt zusammenfassen, also irgendwie so: if (or (= 0 (rem i 3)) (= 0 (rem i 5))) ...

Ich schätze mal, dass es für listenartige Strukturen eine Möglichkeit zum Filtern und Falten geben müsste, also analog zu Scala:
(1 to 1000).filter(n => (n % 3 == 0) || (n % 5 == 0)).foldLeft(0)(_ + _)
oder kürzer
(1 to 1000).filter(n => (n % 3 == 0) || (n % 5 == 0)).sum

In gewöhnlichen funktionalen Sprachen natürlich "andersrum"
sum(filter(range(1, 1000), lambda(x) = (n % 3 == 0) || (n % 5 == 0))))

 

[mvitz]

Danke für deine Anmerkung

Falls es wen interessiert:

(defn divisible-by-3-or-5? [num] (or (== (mod num 3) 0)(== (mod num 5) 0))) 

(println (reduce + (filter divisible-by-3-or-5? (range 1000))))

 

[Landei]

Hypsch!

Unter der Oberfläche ähneln sich die funktionalen Sprachen doch mehr, als die Syntax vermuten lässt :-D

 

[mvitz]

Find ich auch, wobei ich ehrlich gestehen muss, dass ich über die Lösung gestolpert bin während ich nach den bestehenden Funktionen für Collections gesucht habe.

 

[JohannisderKaeufer]

Sorry, fürs Leichenfleddern, aber es geht noch ein wenig nicer

(defn divisible 
  [num divs] 
  (some 
    #(zero? (mod num %)) 
    divs))

(reduce + 
  (filter 
    #(divisible % '(3 5)) 
    (range 1000)))

Der Vergleich mit 0 läßt sich auch mit

zero?

bewerkstelligen.

Und das Konstrukt mit dem

or

läßt sich mit

(some Funktion '(Liste mit Parametern))

etwas knackiger ausdrücken.

Eine weitere schöne Alternative mittels eines Mappings auf den Restwert der Divisionen und das Reduzieren mittels Multiplikation mit anschließendem Prüfen auf 0.

(defn divisible 
  [num divs] 
  (zero? 
    (reduce * 
      (map 
        #(mod num %) 
        divs))))

Map- Reduce halt.