1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
using Base, StatsBase
 
#=
Nota bene :
 
que quote est un mot clé en Julia
que l'on ajoute un texte à un autre avec *
que l'on produit plusieurs caractères avec ^ : "'"^5
=#
 
function signe(n)
    r = ""
    items = ["'", "o"]
    weights = [0.8, 0.2]
    for _ in 1:n
        r = r * sample(items, Weights(weights))
    end
    return r
end
 
function sapin(n)
    println()
 
    for k in 1:n
        if k == 1
            println(" "^(2n - 2) * "*")
            println(" "^(2n - 2) * "^")
        elseif k == 2
            println(" "^(2n - 3) * "/\"\\")
        else
            println(" "^((2n - 2) - k) * "/" * signe(2k - 1) * "\\")
        end
    end
 
    pied = " "^(2n - 3) * "|||"
 
    println(pied)
    println(pied)
    println(pied)
    println()
end
 
function main()
    sapin(15)
end
 
@time main()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
using Base, StringDistances
 
# https://github.com/matthieugomez/StringDistances.jl
 
function correcteur(mots, liste)
    for mot in mots
        r = StringDistances.findnearest(mot, liste, Levenshtein(), min_score = 0.65)
        @show r[1]
    end
end
 
function main()
    liste_référence = ["chien", "chat", "taux", "tour", "train", "voiture", "bonjour", "bonsoir", "merci", "aaaa", "adaf", "acae"]
    mots_cherché = ["taur", "axae", "bonvour", "bonsoir", "juste"]
 
    correcteur(mots_cherché, liste_référence)
 
    return
 
    #=
        r[1] = "tour"
        r[1] = "acae"
        r[1] = "bonjour"
        r[1] = "bonsoir"
        r[1] = nothing
        0.000585 seconds (172 allocations: 13.781 KiB)
    =#
end
 
@time main()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
using Base, Dates
 
# on défini les struct
struct Personne
    nom::String
    prénom::String
end
 
struct Equipe
    indice::Int16
    personne_1::Personne
    personne_2::Personne
    personne_3::Personne
end
 
struct Année
    an::Int16
    indice_rotation::Array{Int16}
end
 
struct tranche_horaire
    nom::String
    durée::Int16
    tranche::String
end
 
struct Result
    indice_équipe::Int16
    date::DateTime
    indice_horaire::Int16
end
 
# on personalise l'affichage
Base.show(io::IO, p::Personne) = println(io, " $(p.nom) $(p.prénom) ")
Base.show(io::IO, e::Equipe) = println(io, " Equipe $(e.indice) : $(e.personne_1), $(e.personne_2), $(e.personne_3) ")
Base.show(io::IO, t::tranche_horaire) = println(io, " $(t.nom) $(t.tranche) ")
 
# on construit l'indice de rotation pour un an
function construire_indice_rotation(nombre_jours_an)
    n = 1
    r = [1]
    for i in 1:1:nombre_jours_an
        if n > nombre_jours_an - 1
            break
        end
        push!(r, r[i] + mod(i, 2))
        n = n + 1
    end
    pushfirst!(r, 1)
    return r
end
 
# on utilise la version Julia de l'algorithme
function indice_horaire(indice_équipe, indice_rotation)
    return mod(indice_équipe + indice_rotation - 2, 4) + 1
end
 
function main()
 
    # on défini les tranches horaires
    H1 = tranche_horaire("Matin", 8, "de 5 h à 13 h")
    H2 = tranche_horaire("Après_midi", 8, "de 13 h à 21 h")
    H3 = tranche_horaire("Nuit", 8, "de 21 h à 5 h")
    H4 = tranche_horaire("Repos", 0, "toute la journée")
 
    Hn = [H1, H2, H3, H4]
 
    # on défini les équipes
    équipe_1 = Equipe(
        1,
        Personne("Dupond", "Jean"), 
        Personne("Lagarde", "Hector"), 
        Personne("Durand", "Henri")
    )
 
    équipe_2 = Equipe(
        2,
        Personne("Dupond", "Pierre"), 
        Personne("Lagarde", "François"), 
        Personne("Durand", "Jean Paul")
    )
 
    équipe_3 = Equipe(
        3,
        Personne("Dupond", "Henri"), 
        Personne("Lagarde", "Jean"), 
        Personne("Durand", "Hector")
    )
 
    équipe_4 = Equipe(
        4,
        Personne("Dupond", "François"), 
        Personne("Lagarde", "Jean Paul"), 
        Personne("Durand", "Pierre")
    )
 
    En = [équipe_1, équipe_2, équipe_3, équipe_4]
 
    # le nombre de jour en 2021
    days_in_year_2021 = daysinyear(2021)
 
    # on défini l'année 2021
    an_2021 = Année(
        2021,
        construire_indice_rotation(days_in_year_2021)
    )
 
    # le premier janvier de 2021
    date_2021_1_1 = DateTime(2021, 1, 1)
 
    # exemple, calcul des horaires pour l'équipe 2
    let r = []
 
        println("==== Exemple 1 ====")
 
        # on traite les 15 premiers jours de l'année
        for k in 1:1:15 
            push!(r, [date_2021_1_1 + Day(k-1), 
            indice_horaire(équipe_2.indice, an_2021.indice_rotation[k])])
        end
 
        # on affiche le résultat
        for k in r
            println("$(k[1]) : indice_horaire $(k[2])")
        end
 
        #=
            2021-01-01T00:00:00 : indice_horaire 2
            2021-01-02T00:00:00 : indice_horaire 2
            2021-01-03T00:00:00 : indice_horaire 3
            2021-01-04T00:00:00 : indice_horaire 3
            2021-01-05T00:00:00 : indice_horaire 4
            2021-01-06T00:00:00 : indice_horaire 4
            2021-01-07T00:00:00 : indice_horaire 1
            2021-01-08T00:00:00 : indice_horaire 1
            2021-01-09T00:00:00 : indice_horaire 2
            2021-01-10T00:00:00 : indice_horaire 2
            2021-01-11T00:00:00 : indice_horaire 3
            2021-01-12T00:00:00 : indice_horaire 3
            2021-01-13T00:00:00 : indice_horaire 4
            2021-01-14T00:00:00 : indice_horaire 4
            2021-01-15T00:00:00 : indice_horaire 1 
       =#
    end
 
    # exemple, calcul de l'horaire du 2021-11-17 pour l'équipe 2
    let date_t = DateTime(2021, 11, 17), day_of_year = dayofyear(date_t)
 
        println("==== Exemple 2 ====")
 
        # indice horaire pour l'équique 2 pour le jour day_of_year/days_in_year_2021
        indice_horaire_2 = indice_horaire(équipe_2.indice, an_2021.indice_rotation[day_of_year])
 
        println("$(équipe_2) \n $(date_t) : $(Hn[indice_horaire_2])")
 
        #=
            Equipe 2 : Dupond Jean, Lagarde Hector, Durand Henri 
 
            2021-11-17T00:00:00 :  Après_midi de 13 h à 21 h 
        =#
    end
 
    # exemple, calcul des horaires du 2021-06-01 au 2021-07-15 pour toutes les équipes
    let date_t_1 = DateTime(2021, 6, 1),
        day_of_year_1 = dayofyear(date_t_1),
        date_t_2 = DateTime(2021, 7, 15), 
        day_of_year_2 = dayofyear(date_t_2)
 
        println("==== Exemple 3 ====")
 
        # r contiendra un array de Result
        r = []
 
        for E in En
            for D in day_of_year_1:1:day_of_year_2
                push!(r, Result(E.indice, date_2021_1_1 + Day(D-1), indice_horaire(E.indice, an_2021.indice_rotation[D])))
            end
        end
 
        for k in r
            println("Equipe $(k.indice_équipe) \n $(k.date) : $(Hn[k.indice_horaire])")
        end
 
        #=
            Equipe 1
            2021-06-01T00:00:00 :  Repos toute la journée
 
            Equipe 1
            2021-06-02T00:00:00 :  Matin de 5 h à 13 h
 
            Equipe 1
            2021-06-03T00:00:00 :  Matin de 5 h à 13 h
 
            Equipe 1
            2021-06-04T00:00:00 :  Après_midi de 13 h à 21 h
 
            Equipe 1
            2021-06-05T00:00:00 :  Après_midi de 13 h à 21 h
 
            Equipe 1
            2021-06-06T00:00:00 :  Nuit de 21 h à 5 h
            ... 
 
            Equipe 4
            2021-07-12T00:00:00 :  Repos toute la journée
 
            Equipe 4
           2021-07-13T00:00:00 :  Repos toute la journée
 
           Equipe 4
           2021-07-14T00:00:00 :  Matin de 5 h à 13 h
 
           Equipe 4
           2021-07-15T00:00:00 :  Matin de 5 h à 13 h
        =#
 
    end
 
    return
end
 
@time main() # 0.135841 seconds (282.31 k allocations: 16.842 MiB, 74.41% compilation time)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
using Base
 
function main()
    d1 = Dict("a" => 1.0, "b" => 1.1, "c" => 1.9)
    d2 = Dict("a" => 1.1, "b" => 1.4, "c" => 1.3)
    d3 = Dict("a" => 1.2, "b" => 1.3, "c" => 1.4)
    d10 = Dict("a" => 1.0, "b" => 3.5, "c" => 1.9)
    d20 = Dict("a" => 1.1, "b" => 1.4, "c" => 1.3)
    d30 = Dict("a" => 1.2, "b" => 1.3, "c" => 1.4)
    d100 = Dict("a" => 1.0, "b" => 1.1, "c" => 1.9)
    d200 = Dict("a" => 2.5, "b" => 1.4, "c" => 1.3)
    d300 = Dict("a" => 1.2, "b" => 1.3, "c" => 1.4)
    d1000 = Dict("a" => 1.0, "b" => 1.1, "c" => 1.9)
    d2000 = Dict("a" => 1.1, "b" => 1.4, "c" => 4.5)
    d3000 = Dict("a" => 1.2, "b" => 1.3, "c" => 1.4)
 
    array_dict = [d1, d2, d3, d10, d20, d30, d100, d200, d300, d1000, d2000, d3000]
 
    a = maximum(x -> x["a"], array_dict)
    b = maximum(x -> x["b"], array_dict)
    c = maximum(x -> x["c"], array_dict)
 
    (a, b, c) |> println
 
    dr = Dict("a" => a, "b" => b, "c" => c)
 
    @show dr
end
 
@time main()
@time main()
 
#=
(2.5, 3.5, 4.5)
dr = Dict("c" => 4.5, "b" => 3.5, "a" => 2.5)
  0.140124 seconds (479.21 k allocations: 26.631 MiB, 6.08% gc time, 98.97% compilation time)
 
(2.5, 3.5, 4.5)
dr = Dict("c" => 4.5, "b" => 3.5, "a" => 2.5)
  0.000971 seconds (176 allocations: 13.875 KiB)
 
Dict{String, Float64} with 3 entries:
  "c" => 4.5
  "b" => 3.5
  "a" => 2.5
=#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
using Statistics
 
function main()
    ListNotes = [["Mathématiques", 12], ["Mathématiques", 9], ["Mathématiques", 15], 
    ["Informatique", 17], ["Physique", 11], ["Physique", 8], 
    ["Chimie", 16], ["Chimie", 10]]
 
    notes = Dict{String, Vector{Int64}}()
    moyennes = Dict{String, Float64}()
 
    for item in ListNotes
        key = item[1]
        value = item[2]
 
        if haskey(notes, key)
            push!(notes[key], value) # push dans un array
        else
            push!(notes, key => [ value ]) # push dans un dict
        end
    end
 
    for (key, value) in pairs(notes)
        push!(moyennes, key => mean(value))
    end
 
    @show notes
    @show moyennes
end
 
@time main()
 
#=
notes = Dict("Informatique" => [17], "Mathématiques" => [12, 9, 15], "Physique" => [11, 8], "Chimie" => [16, 10])
moyennes = Dict("Informatique" => 17.0, "Mathématiques" => 12.0, "Physique" => 9.5, "Chimie" => 
13.0)
  0.000845 seconds (296 allocations: 17.109 KiB)
=#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
using Unitful, QuadGK, Plots, PlotThemes
 
gr()
theme(:juno)
 
#=
Dans Julia, il est possible de calculer des intégrales numériquement 
en tenant compte des unités de mesure. Par exemple, si nous intégrons 
une vitesse sur un intervalle de temps, nous obtiendrons la distance 
parcourue.
=#
 
a = 0.143u"m/s^2"
 
# vf = vi + at avec vi = 0
# on veut le résultat en kilomètre au lieu de m.
d = uconvert(u"km", quadgk(x -> a*x, 0u"s", 145u"s")[1])
 
@show d
 
# le temps de parcours en seconde
t = (0:145)u"s"
 
# on veut la vitesse en kilomètre par heure au temps t en seconde.
v = [uconvert(u"km/hr", a*x) for x in t]
 
@show t
@show v
 
# plot ne prend que des chiffres sans unité, on utilise ustrip()
plot(ustrip(t), ustrip(v), ylabel="km/hr", xlabel="s", grid=true, gridwidth=3, legend=:none, title="Vitesse au temps t")

1
2
3
using Pluto
 
Pluto.run()

1
2
3
4
5
6
7
8
9
10
11
12
begin
	using PlutoUI, DifferentialEquations, PlotThemes, Plots
	gr()
	theme(:juno)
 
	html"""<style>
	main {
		max-width: 1000px;
		background-color: rgba(55, 55, 128, .35);
	}
	"""
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
### A Pluto.jl notebook ###
# v0.12.21
 
using Markdown
using InteractiveUtils
 
# This Pluto notebook uses @bind for interactivity. When running this notebook outside of Pluto, the following 'mock version' of @bind gives bound variables a default value (instead of an error).
macro bind(def, element)
    quote
        local el = $(esc(element))
        global $(esc(def)) = Core.applicable(Base.get, el) ? Base.get(el) : missing
        el
    end
end
 
# ╔═╡ 89df9682-7b94-11eb-39a5-2f696f5ca3ba
begin
	using PlutoUI, Dates, TimeZones, PlotThemes, Plots, DifferentialEquations
	gr()
	theme(:juno)
	TimeZones.build()
 
	html"""<style>
	main {
		max-width: 1000px;
		background-color: rgba(237, 196, 33, .55);
	}
	"""
end
 
# ╔═╡ 9529ec10-7ccb-11eb-2747-a7ef8617ee32
md"### ODE Lorentz"
 
# ╔═╡ 9689f560-7d88-11eb-3586-fb21f55ed458
begin
	zdt = ZonedDateTime(DateTime("2021-03-05T08:54:48.908+01:00", "yyyy-mm-ddTHH:MM:SS.ssszz"), tz"Europe/Brussels")
	md"Daniel Hagnoul $zdt"
end
 
# ╔═╡ a3d3e000-7b94-11eb-27c5-434ad0dbf8ae
function parameterized_lorenz!(du,u,p,t)
     x,y,z = u
     σ,ρ,β = p
     du[1] = dx = σ*(y-x)
     du[2] = dy = x*(ρ-z) - y
     du[3] = dz = x*y - β*z
end;
 
# ╔═╡ b20be3c0-7d88-11eb-11b4-fb1858161fb1
md"x : $(@bind x Slider(1:3, default=1, show_value=true))
 
y : $(@bind y Slider(0:3, default=0, show_value=true))
 
z : $(@bind z Slider(0:3, default=0, show_value=true))
 
sigma : $(@bind sigma Slider(6:14, default=10, show_value=true))
 
rho : $(@bind rho Slider(24:32, default=28, show_value=true))
 
beta : $(@bind beta Slider(2.0:0.1:3.0, default=2.67, show_value=true))
 
ts : $(@bind ts Slider(1:5:200, default=80, show_value=true))"
 
# ╔═╡ c81f68ce-7b94-11eb-3a16-df6d15044c76
begin
	u0 = [x; y; z]
	tspan = (0.0, ts)
	p = [sigma, rho, beta]
 
	prob = ODEProblem(parameterized_lorenz!, u0, tspan, p)
	sol = solve(prob)
 
	plot(sol, vars=(1,2,3), gridlinewidth=3.0, legend=:none)
end
 
# ╔═╡ Cell order:
# ╟─89df9682-7b94-11eb-39a5-2f696f5ca3ba
# ╟─9529ec10-7ccb-11eb-2747-a7ef8617ee32
# ╟─9689f560-7d88-11eb-3586-fb21f55ed458
# ╠═a3d3e000-7b94-11eb-27c5-434ad0dbf8ae
# ╟─b20be3c0-7d88-11eb-11b4-fb1858161fb1
# ╠═c81f68ce-7b94-11eb-3a16-df6d15044c76

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
### A Pluto.jl notebook ###
# v0.12.21
 
using Markdown
using InteractiveUtils
 
# This Pluto notebook uses @bind for interactivity. When running this notebook outside of Pluto, the following 'mock version' of @bind gives bound variables a default value (instead of an error).
macro bind(def, element)
    quote
        local el = $(esc(element))
        global $(esc(def)) = Core.applicable(Base.get, el) ? Base.get(el) : missing
        el
    end
end
 
# ╔═╡ 1a109d00-7c01-11eb-3abf-4f4a68e9116d
begin
	using PlutoUI, DifferentialEquations, PlotThemes, Plots
	gr()
	theme(:juno)
 
	html"""<style>
	main {
		max-width: 1000px;
		background-color: rgba(237, 196, 33, .55);
	}
	"""
end
 
# ╔═╡ 37f8d590-7cc8-11eb-2268-5d36dc6d9ad2
md"### Mes premiers pas avec Pluto"
 
# ╔═╡ 54b4f1a0-7cc8-11eb-1dbd-31683c668a4b
md"##### Un slider"
 
# ╔═╡ 015ca210-7c09-11eb-0e19-9114b50da274
md"m : $(@bind m Slider(1:10, default=5, show_value=true))"
 
# ╔═╡ 14424450-7cc9-11eb-1df9-dd7e16252857
md"##### Print()"
 
# ╔═╡ 4789bbbe-7c0d-11eb-16cc-03feb7b380fa
Print(m .* rand(10))
 
# ╔═╡ 2d7d9e10-7cc9-11eb-0535-6533266eeb44
md"##### Conseil pour afficher une valeur"
 
# ╔═╡ 0400ceb0-7cc7-11eb-0f77-fd0bddafadba
md"Vous ne pouvez pas utiliser print, println, @show ou |> println directement, le résultat s'afficherai alors dans le terminal VSCode. Il faut utiliser Print() ou with_terminal(), exemple ci-dessous."
 
# ╔═╡ 6d761cde-7cc9-11eb-34c0-e76fa559d14a
md"##### with_terminal() do"
 
# ╔═╡ 834cb2b2-7cc7-11eb-0302-ed67a6187dc2
with_terminal() do
	@show valeur = 1 + 1 ÷ 2
	1 + 1 ÷ 2 |> println
	println("Le résultat de mon calcul est $(1 + 1 ÷ 2)")
end
 
# ╔═╡ 7da729b0-7cc9-11eb-2a19-11d4b2fbb9e0
md"##### Plot"
 
# ╔═╡ c62b56f0-7cc6-11eb-2d00-3bffaa0bb1af
plot(1:10, log.(m .* rand(10)))
 
# ╔═╡ Cell order:
# ╟─1a109d00-7c01-11eb-3abf-4f4a68e9116d
# ╟─37f8d590-7cc8-11eb-2268-5d36dc6d9ad2
# ╟─54b4f1a0-7cc8-11eb-1dbd-31683c668a4b
# ╟─015ca210-7c09-11eb-0e19-9114b50da274
# ╟─14424450-7cc9-11eb-1df9-dd7e16252857
# ╟─4789bbbe-7c0d-11eb-16cc-03feb7b380fa
# ╟─2d7d9e10-7cc9-11eb-0535-6533266eeb44
# ╟─0400ceb0-7cc7-11eb-0f77-fd0bddafadba
# ╟─6d761cde-7cc9-11eb-34c0-e76fa559d14a
# ╟─834cb2b2-7cc7-11eb-0302-ed67a6187dc2
# ╟─7da729b0-7cc9-11eb-2a19-11d4b2fbb9e0
# ╟─c62b56f0-7cc6-11eb-2d00-3bffaa0bb1af

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
using DataStructures
 
const accentdict = Dict(
    'À'=> 'A', 'Á'=> 'A', 'Â'=> 'A', 'Ã'=> 'A', 'Ä'=> 'A',
    'Å'=> 'A', 'Ç'=> 'C', 'È'=> 'E', 'É'=> 'E',
    'Ê'=> 'E', 'Ë'=> 'E', 'Ì'=> 'I', 'Í'=> 'I', 'Î'=> 'I',
    'Ï'=> 'I', 'Ñ'=> 'N', 'Ò'=> 'O', 'Ó'=> 'O',
    'Ô'=> 'O', 'Õ'=> 'O', 'Ö'=> 'O', 'Ù'=> 'U', 'Ú'=> 'U',
    'Û'=> 'U', 'Ü'=> 'U', 'Ý'=> 'Y', 'à'=> 'a', 'á'=> 'a',
    'â'=> 'a', 'ã'=> 'a', 'ä'=> 'a', 'å'=> 'a', 'è'=> 'e',
    'é'=> 'e', 'ê'=> 'e', 'ë'=> 'e', 'ì'=> 'i', 'í'=> 'i',
    'î'=> 'i', 'ï'=> 'i', 'ð'=> 'd', 'ñ'=> 'n', 'ò'=> 'o',
    'ó'=> 'o', 'ô'=> 'o', 'õ'=> 'o', 'ö'=> 'o', 'ù'=> 'u', 
    'ú'=> 'u', 'û'=> 'u', 'ü'=> 'u', 'ý'=> 'y', 'ÿ'=> 'y')
 
function main()
    # pour le tri avec accent
    function tr(str, dict=accentdict)
        for (i, ch) in enumerate(str)
            if haskey(dict, ch)
                arr = split(str, "")
                arr[i] = string(dict[ch])
                str = join(arr)
            end
        end
        str
    end
 
    isless(x, y) = tr(x) < tr(y)
 
    # texte
    texte = """
        C'est l'évadé, du Névada.
        Qui s'évada dans, la vallée
        Dans la vallée, du Névada ?
        Qu'il dévala, pour s'évader
        Sur un vilain vélo volé !
        Qu'il a volé, dans une villa
        Et le valet, qui fut volé.
        Vit l'évadé, qui s'envola
    """
 
    texte_low = lowercase(texte)
 
    # trouve les mots corespondants au contenu du regex
    myregex = r"[a-zA-Z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF]*" 
    words = map(range->texte_low[range], findall(myregex, texte_low))
    lst = sort([x for x in words if length(x) > 2], lt=isless)
 
    # génére un Dict dans l'ordre avec accent
    cnt = sort(Dict(counter(lst)), lt=isless)
 
    @show nb_de_mots = length(lst)
    cnt |> println
end
 
@time main()
@time main()
#=
    nb_de_mots = length(lst) = 29
    OrderedDict(
        "dans" => 3, 
        "dévala" => 1, 
        "envola" => 1, 
        "est" => 1, 
        "évada" => 1, 
        "évadé" => 2, 
        "évader" => 1, 
        "fut" => 1, 
        "névada" => 2, 
        "pour" => 1, 
        "qui" => 3, 
        "sur" => 1, 
        "une" => 1, 
        "valet" => 1, 
        "vallée" => 2, 
        "vélo" => 1, 
        "vilain" => 1, 
        "villa" => 1, 
        "vit" => 1, 
        "volé" => 3)
    0.328102 seconds (638.02 k allocations: 38.409 MiB, 2.23% gc time, 97.98% compilation time)
    0.004801 seconds (9.12 k allocations: 588.281 KiB)
=#