(je comprends pas trop de quoi tu parles, certes ma fonction est très crade
mais je ne comprends pas cette critique précise...)
mais je ne comprends pas cette critique précise...)
))
class ['a] element_liste (valeur : 'a) =
object
method valeur = valeur
val mutable suite = None
method ajoute_apres (lasuite : 'a element_liste) = suite <- Some lasuite
method suite = suite
end
class ['a] liste_avec_fin =
object
val mutable liste = None
val mutable fin = None
method ajoute_apres (valeur : 'a) =
let elt = new element_liste valeur in
begin match fin with
Some fin -> fin#ajoute_apres elt
| None -> liste <- Some elt
end;
fin <- Some elt
method ajoute_avant valeur =
let elt = new element_liste valeur in
begin match liste with
Some liste -> elt#ajoute_apres liste
| None -> fin <- Some elt
end;
liste <- Some elt
method tete =
match liste with
Some liste -> liste#valeur
method queue =
match liste with
Some liste ->
{< fin = if liste#suite = None then None else fin;
liste = liste#suite >}
method est_vide = liste = None
end
:
method queue =
let queue = if fin = liste then {<liste = None; fin = None>} else match liste with Some liste -> {<liste = liste#suite>} in
(queue :> 'a liste_lecture_seule)
(et quel que soit le langage de programmation ^^)
Moumou :
euh une liste je la représente par un triplet donnée, pointeur vers le prochain élément, booléen pour savoir si c'est la fin de la liste. Et la liste en O(1) par la queue, je la représente par un couple liste, pointeur vers le dernier élément de cette liste.
(enfin en caml on peut, mais en C on pointe forcément vers un endroit dans la mémoire (qui donc lui aussi contient qqch qu'on peut assimiler à une adresse), nan ?))
type 'a liste_mutable = { tete : 'a; mutable queue : 'a liste_mutable option }
type 'a liste_avec_fin =
{ debut : 'a liste_mutable; mutable fin : 'a liste_mutable }
let ajoute_en_queue a l =
let nouveau = {tete = a; queue = None} in
l.fin.queue <- Some nouveau; l.fin <- nouveau
let rec est_non_premier n racinen listepremiers =
if listepremiers.tete > racinen then false
else
n mod listepremiers.tete = 0 ||
(match listepremiers.queue with
None -> false
| Some suite -> est_non_premier n racinen suite)
let rec premier_suivant n listepremiers =
if est_non_premier n (int_of_float (sqrt (float_of_int n))) listepremiers
then
premier_suivant (n + 1) listepremiers
else n
let ajoute_premier_suivant listepremiers_avecfin =
ajoute_en_queue
(premier_suivant (listepremiers_avecfin.fin.tete + 1)
listepremiers_avecfin.debut)
listepremiers_avecfin
let rec list_of_liste_mutable liste_mutable =
liste_mutable.tete ::
(match liste_mutable.queue with
None -> []
| Some l -> list_of_liste_mutable l)
let premierspremiers n =
let listepremiers_avecfin =
let listepremiers = {tete = 2; queue = None} in
{debut = listepremiers; fin = listepremiers}
in
for i = 1 to n - 1 do ajoute_premier_suivant listepremiers_avecfin done;
list_of_liste_mutable listepremiers_avecfin.debut
Sally :type 'a liste_mutable = { tete : 'a; mutable queue : 'a liste_mutable option } type 'a liste_avec_fin = { debut : 'a liste_mutable; mutable fin : 'a liste_mutable } let ajoute_en_queue a l = let nouveau = {tete = a; queue = None} in l.fin.queue <- Some nouveau; l.fin <- nouveau let rec est_non_premier n racinen listepremiers = if listepremiers.tete > racinen then false else n mod listepremiers.tete = 0 || (match listepremiers.queue with None -> false | Some suite -> est_non_premier n racinen suite) let rec premier_suivant n listepremiers = if est_non_premier n (int_of_float (sqrt (float_of_int n))) listepremiers then premier_suivant (n + 1) listepremiers else n let ajoute_premier_suivant listepremiers_avecfin = ajoute_en_queue (premier_suivant (listepremiers_avecfin.fin.tete + 1) listepremiers_avecfin.debut) listepremiers_avecfin let rec list_of_liste_mutable liste_mutable = liste_mutable.tete :: (match liste_mutable.queue with None -> [] | Some l -> list_of_liste_mutable l) let premierspremiers n = let listepremiers_avecfin = let listepremiers = {tete = 2; queue = None} in {debut = listepremiers; fin = listepremiers} in for i = 1 to n - 1 do ajoute_premier_suivant listepremiers_avecfin done; list_of_liste_mutable listepremiers_avecfin.debut
class InfiniteRange
include Enumerable
def initialize(n)
@n=n
end
def each(&block)
i=@n
while true
yield i+=1
end
end
end
primes=[2]
(ARGV.shift.to_i-1).times {
primes << InfiniteRange.new(primes[-1]).find{|n|
!primes.find{|p| n%p==0 } && n
}
}
p primes
infinity=1.0/0
primes=[2]
n=ARGV.shift.to_i
(n-1).times {
primes << (primes[-1]+1..infinity).find{|n|
!primes.find{|p| n%p==0 } && n
}
}
p primes
), je te rappelle juste que si on a fait tout ce bidouillage c'est dans l'unique but d'optimiser en s'arrêtant à racine(n), ce que tu n'as pas l'air de faire. Bon peut-être que ça ne compliquerait pas beaucoup ton code de le faire j'en sais rien mais voilà quoi ^^
let rec est_non_premier n = function [] -> false | p :: suite -> n mod p = 0 || est_non_premier n suite let ajoute_prochain_premier = function [] -> [2] | p::suite as liste -> let rec aux n liste = if est_non_premier n liste then aux (n + 1) liste else n in aux (p + 1) liste :: liste let premiers_premiers n = let liste = ref [] in for i = 1 to n do liste := ajoute_prochain_premier !liste done; !liste