Progblemet #2

; Denna version är "vanlig" emacs-lisp som saknar en "range" 
; funktion, så jag har skapat en som fungerar som i Clojure
(defun range (from to)
  "Returns a list with integers [from..to)"
  (let ((lst '())
        (n to))
    (while (not (= from n))
      (setq n (1- n))
      (setq lst (cons n lst)))
    lst))

; Denna funktion fungerar på följande sätt
; 'apply' är en funktion som kommer applicera en funktion, i detta fall +, på alla element i listan som ges som argument 2
; Funktionen + ska inte evalueras innan den skickas som argument och ' (quote) ser till detta
;  Det som ska summeras är resultatet av funktionen 'mapcar' som kör en funktion (första argumentet) på alla element i en lista (argument 2)
; I detta fall har vi en anonym funktion som i emacs-lisp (och de flesta andra Lisp dialekter) skapas med 'lambda'
; Den anonyma funktionen tar ett argument som här kallas 'n'
; Den anonyma funktionen ger resultatet av 'n' om 'n' är jämt delbart med 3 eller 5 annars blir resultatet 0
; Denna funktion körs på alla heltal från 1 till up-to minus 1 då (range a b) ger en lista med tal från a till b-1.
(defun sum-multiplies (up-to)
  (apply
   '+
   (mapcar
    (lambda (n)
      (if (or (zerop (% n 3)) (zerop (% n 5))) n 0))
    (range 1 up-to))))

(insert (format "\n%d" (sum-multiplies 1000)))
; Kör genom att ställa dig på denna rad och skriv
; \M-x eval-buffer

sum_multiplies up_to = foldr (+) 0 [ n | n <- [1..(up_to-1)], (n `mod` 3) == 0 || (n `mod` 5) == 0]

main = do
  print (sum_multiplies 1000)

(for (n <- 1 until 1000 if n % 3 == 0 || n % 5 == 0) yield n).sum

1 until 1000 filter (n => n % 3 * n % 5 == 0) sum

1 until 1000				En range från 1 till och med 999.
filter (n => n % 3 * n % 5 == 0)	Filtrera ut de tal som är jämnt delbara med 3 eller 5
sum					Summera.

sum=0; for x in $(seq 1 999); do if [ $(($x % 3 == 0 || $x % 5 == 0)) != 0 ]; then sum=$(($sum + $x)); fi; done; echo $sum

Console.WriteLine(Enumerable.Range(0, 1000).Where(n => n % 3 == 0 || n % 5 == 0).Sum());

(->> (range 1000) 
   (filter (fn [n] (or (zero? (mod n 3)) (zero? (mod n 5))))) 
   (reduce +))

#include <stdio.h>

int sum_multiplies(int sum, int n)
{
    if (n == 0)
        return sum;
    return sum_multiplies(sum + (!(n % 3) || !(n % 5) ? n : 0), n - 1);
}

int main()
{
    printf("%d\n", sum_multiplies(0, 999));
}

#include <stdio.h>

int sum_multiplies(int sum, int n)
{
    if (n == 0)
        return sum;
    return sum_multiplies(sum + (!(n % 3) || !(n % 5) ? n : 0), n - 1);
}

int main()
{
    printf("%d\n", sum_multiplies(0, 999));
}

int sum = 0;	
[&] (int i) { while (--i) {sum += i*( !(i%3) || !(i%5) );} }(1000);

$ time ./euler1
233168

real	0m0.001s
user	0m0.000s
sys	0m0.000s

(1..999).select{|x| x%3==0 || x%5==0}.inject(0){|sum,n| sum+n}

#include <iostream>

template <int n>
struct Sum
{
	enum { sum = n*( !(n%3) || !(n%5) ) + Sum<n-1>::sum };
};

template <>
struct Sum<1>
{
	enum { sum = 0 };
};

int main()
{	
	std::cout << Sum<999>::sum << std::endl;
}

(ns progblemet2
    (:gen-class))

(defmacro macro-sum-mul[N]
  (apply + (filter (fn [x] (or (zero? (mod x 3)) (zero? (mod x 5)))) (range N))))

(defn fun-sum-mul[N]
  (apply + (filter (fn [x] (or (zero? (mod x 3)) (zero? (mod x 5)))) (range N))))

(defn -main[]
  (println (time (fun-sum-mul 1000))))
  (println (time (macro-sum-mul 1000)))

  (println (time (fun-sum-mul 1000))))
  (println (time 233168))

#include <iostream>

template<int limit, int n>
struct Num
{
	enum { num = (limit - 1) / n };
};

template<int n>
struct Sum
{
	enum { sum = n * (n + 1) / 2 };
};

template<int limit, int n>
struct Res
{
	enum { res = Sum<Num<limit,n>::num>::sum * n };
};

template<int limit, int n, int m>
struct FinalRes
{
	enum { res = Res<limit,n>::res + Res<limit,m>::res - Res<limit,n*m>::res };
};

int main(int argc, char** argv)
{
	std::cout << FinalRes<1000,3,5>::res << std::endl;
	return 0;
}

#include <iostream>

int f(int limit, int n)
{
	int num = (limit - 1) / n;
	int sum = num * (num + 1) / 2;
	return sum * n;
}

int main(int argc, char** argv)
{
	std::cout << f(1000,5) + f(1000,3) - f(1000,3*5) << std::endl;
	return 0;
}

/**
 * Arithmetic
 */

template<typename A, typename B> struct Add;
template<typename A, typename B> struct Sub;
template<typename A, typename B> struct Mul;
template<typename A, typename B> struct Div;

/**
 * Integer
 */

template<int N> struct Int
{
	enum { value = N };
};

template<int N, int M> struct Add<Int<N>,Int<M>>
{
	typedef Int<N+M> result;
};

template<int N, int M> struct Sub<Int<N>,Int<M>>
{
	typedef Int<N-M> result;
};

template<int N, int M> struct Mul<Int<N>,Int<M>>
{
	typedef Int<N*M> result;
};

template<int N, int M> struct Div<Int<N>,Int<M>>
{
	typedef Int<N/M> result;
};

/**
 * List
 */

struct Empty;
template<typename X, typename XS> struct List;

template<typename YS> struct Add<Empty,YS>
{
	typedef YS result;
};

template<typename XS> struct Add<XS,Empty>
{
	typedef XS result;
};

template<typename X, typename XS, typename Y, typename YS>
struct Add<List<X,XS>,List<Y,YS>>
{
	typedef List<X,typename Add<XS,List<Y,YS>>::result> result;
};

/**
 * Foldl
 */

template<template<typename,typename> class F, typename Z, typename XS>
struct Foldl;

template<template<typename,typename> class F, typename Z>
struct Foldl<F, Z, Empty>
{
	typedef Z result;
};

template<template<typename,typename> class F, typename Z, typename X, typename XS>
struct Foldl<F, Z, List<X,XS>>
{
	typedef typename Foldl<F,typename F<Z,X>::result,XS>::result result;
};

/**
 * Map
 */

template<template<typename> class F, typename XS>
struct Map;

template<template<typename> class F>
struct Map<F, Empty>
{
	typedef Empty result;
};

template<template<typename> class F, typename X, typename XS>
struct Map<F, List<X,XS>>
{
	typedef List<typename F<X>::result,typename Map<F,XS>::result> result;
};

/**
 * Tuples
 */

template<typename A, typename B> struct Tuple;

template<typename T> struct MultTuple;
template<typename A, typename B> struct MultTuple<Tuple<A,B>>
{
	typedef typename Mul<A,B>::result result;
};

template<typename X> struct PairWithListElem
{
	template<typename E> struct F
	{
		typedef Tuple<X,E> result;
	};
};

template<typename XS> struct MakePairsFromList;

template<> struct MakePairsFromList<Empty>
{
	typedef Empty result;
};

template<typename X> struct MakePairsFromList<List<X,Empty>>
{
	typedef Empty result;
};

template<typename X, typename XS> struct MakePairsFromList<List<X,XS>>
{
	typedef
		typename Add<
			typename Map<PairWithListElem<X>::template F,XS>::result,
			typename MakePairsFromList<XS>::result
		>::result
	result;
};

/**
 * Le actual problem
 */

template<typename L, typename N> struct Num;
template<int L, int N> struct Num<Int<L>,Int<N>>
{
	typedef
		typename Div<
			typename Sub<
				Int<L>,
				Int<1>
			>::result,
			Int<N>
		>::result
	result;
};

template<typename N> struct Sum;
template<int N> struct Sum<Int<N>>
{
	typedef
		typename Div<
			typename Mul<
				Int<N>,
				typename Add<
					Int<N>,
					Int<1>
				>::result
			>::result,
			Int<2>
		>::result
	result;
};

template<typename L, typename N> struct SumLN;
template<int L, int N> struct SumLN<Int<L>,Int<N>>
{
	typedef
		typename Mul<
			typename Sum<typename Num<Int<L>,Int<N>>::result>::result,
			Int<N>
		>::result
	result;
};

template<typename T> struct MapSumLN;
template<int L> struct MapSumLN<Int<L>>
{
	template<typename N> struct F;
	template<int N> struct F<Int<N>>
	{
		typedef typename SumLN<Int<L>,Int<N>>::result result;
	};
};

#include <iostream>

int main(int argc, char** argv)
{
	// input
	#define LIMIT Int<1000>
	#define LIST List<Int<3>,List<Int<5>,Empty>>

	// add up sums
	#define MAPPED Map<MapSumLN<LIMIT>::F,LIST>::result
	#define FOLDED Foldl<Add,Int<0>,MAPPED>::result

	// subtract duplicates
	#define PAIRS MakePairsFromList<LIST>::result
	#define PAIRS_MAPPED Map<MultTuple,PAIRS>::result
	#define SUB_LIST Map<MapSumLN<LIMIT>::F,PAIRS_MAPPED>::result
	#define SUB Foldl<Add,Int<0>,SUB_LIST>::result

	#define RESULT Sub<FOLDED,SUB>::result

	std::cout << RESULT::value << std::endl;
	return 0;
}

1000.times.select{ |n| n%3==0||n%5==0 }.reduce(&:+)