# [Clojure] Code Style + Einfachere Lösung?



## mvitz (24. Jun 2010)

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 (29. Jun 2010)

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 (29. Jun 2010)

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 (30. Jun 2010)

Hypsch! 

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


----------



## mvitz (30. Jun 2010)

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 (22. Jan 2013)

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.


----------

