Ajout deuxième partie

README.md

@@ -21,7 +21,7 @@ mono jour10.exe
 |  8   |             |             |                       |                 |   |
 |  9   |             |             |                       |                 |   |
 |  10  |Visual Basic |   vbnc      |  vbnc jour10.vbs      | mono jour10.exe |   |
-|  11  |             |             |                       |                 |   |
+|  11  |   Lua       |             |                       |  lua jour11.lua |   |
 |  12  |             |             |                       |                 |   |
 |  13  |             |             |                       |                 |   |
 |  14  |             |             |                       |                 |   |
@@ -124,6 +124,13 @@ mono jour10.exe
 ```
 
 ## Jour 11
+
+Ce jour utilise le Lua 5.2.4. Il se lance comme en Python avec une commande sur le fichier :
+
+```bash
+lua jour11.lua
+```
+
 ## Jour 12
 ## Jour 13
 ## Jour 14

jour11/jour11.lua

@@ -0,0 +1,124 @@
+-- Calcule le mot suivant 
+-- @param mot string : le mot à incrémenter
+-- @return string : le mot incrémenté
+-- exemple : abcz -> abda
+local function suivant(mot)
+    local len = mot:len()
+    local ret = mot:sub(1, len - 1)
+    if mot:sub(len, len) == 'z' then
+        -- utilisé si abzz par ex. s’appelle récursivment pour trouver acaa
+        ret = suivant(ret) .. 'a' 
+    else
+        ret = ret .. string.char(mot:sub(len, len):byte() + 1)
+    end
+    return ret
+end
+
+-- Détecte s’il existe une suite de 3 lettres consécutives
+-- @param mot string : mot où il faut vérifier s’il y a une suite
+-- @return bool : true s’il y a une suite, false sinon
+-- exemple : uabcie -> true; abecud -> false
+local function suite(mot)
+    local ret = false
+    local pred = nil
+    local i = 1
+    local c = nil
+    -- lorsqu’on trouve la première lettre, on met ret à true et pred à c
+    -- si on trouve la troisième lettre, on met pred à nil. 
+    -- si ret est à true et pred à nil, on a trouvé une suite de 3 lettres
+    while not (ret and pred == nil) and i <= #mot do
+        c = mot:sub(i, i)
+        -- première itération
+        if pred == nil then
+            pred = c
+        elseif pred ~= nil then 
+            if pred:byte() == (c:byte() - 1) then
+                -- si le pred est bien prédecesseur de c, on vérifie ret
+                -- pour modifier ensuite pred en conséquence (nil si fin)
+                if ret then
+                    pred = nil 
+                else
+                    pred = c 
+                    ret = true
+                end
+            else
+                ret = false
+                pred = c
+            end
+        end
+        i = i + 1
+    end
+    return (ret and pred == nil) and true or false
+end
+
+-- Cherche le nombre de double dans un mot
+-- @param mot string : mot à vérifier
+-- @return int : le nombre de double présent
+-- exemple : aaabc -> 1; aacaauxxii -> 4
+local function double(mot)
+    local ret = 0
+    local pred = nil
+    for c in mot:gmatch(".") do
+        -- pred ~= obligatoire car on ne peut pas comparer un char avec un nil
+        if pred ~= nil and pred == c then
+            ret = ret + 1
+            pred = nil
+        else
+            pred = c
+        end
+    end
+    return ret
+end
+
+-- incrémente le mot selon le mauvais caractère
+-- @param mot string : le mot à modifier
+-- @param char string : le caractère à trouver et incrémenter
+-- @return string : le mot modifié ou non
+-- exemple : avec char = i
+-- abcidd -> abcjaa; abcde -> abcde
+local function badChar(mot, char)
+    local ret = mot
+    local tmp = mot:find(char)
+
+    if tmp ~= nil then
+        if tmp == 1 then
+            ret = string.char(ret:sub(tmp, tmp):byte() + 1) .. string.rep('a', #ret - tmp)
+        elseif tmp == ret:len() then
+            ret = ret:sub(1, tmp-1) .. string.char(ret:sub(tmp, tmp):byte() + 1)
+        else
+            ret = ret:sub(1, tmp - 1) .. string.char(ret:sub(tmp, tmp):byte() + 1) .. string.rep('a', #ret - tmp)
+        end
+    end
+    return ret
+end
+
+-- Trouve le mot de passe correspondant aux critères suivants :
+-- * une suite de 3 lettres consécutives au moins
+-- * pas de lettre i, l ou o
+-- * 2 pairs de lettres distinctes (aaa ne compte que pour une paire)
+-- @param mot string : le mot à vérifier et modifier
+-- @return string : le nouveau mot de passe
+local function findPass(mot)
+    local fin = false
+    local ret = mot
+    
+    while not fin do
+        ret = badChar(ret, 'i')
+        ret = badChar(ret, 'l')
+        ret = badChar(ret, 'o')
+        if suite(ret) and double(ret) >= 2 then
+            fin = true
+        else
+            ret = suivant(ret)
+        end
+    end
+    return ret
+end
+
+myInput = "cqjxjnds"
+print("Traitement première partie…")
+myInput = findPass(myInput)
+print("Le nouveau mot de passe est : " .. myInput)
+print("Traitement deuxième partie…")
+myInput = findPass(suivant(myInput))
+print("Le nouveau mot de passe est : " .. myInput)