From 57b9afa2b5b1108945be0494a4344c356cb10c4e Mon Sep 17 00:00:00 2001
From: rick <rick@gnous.eu>
Date: Wed, 24 Mar 2021 18:14:50 +0100
Subject: [PATCH] =?UTF-8?q?Ajout=20doc=20et=20l=C3=A9g=C3=A8res=20modifs?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 jour11/jour11.lua | 51 +++++++++++++++++++++++++++++++----------------
 1 file changed, 34 insertions(+), 17 deletions(-)

diff --git a/jour11/jour11.lua b/jour11/jour11.lua
index c00364f..9f8f5cd 100644
--- a/jour11/jour11.lua
+++ b/jour11/jour11.lua
@@ -1,25 +1,40 @@
+-- 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
-        ret = suivant(ret) .. 'a'
+        -- utilisé si abzz par ex. s’appelle récursivment pour trouver acaa
+        ret = suivant(ret) .. 'a' 
     else
-        ret = ret .. string.char(string.byte(mot:sub(len, len)) + 1)
+        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
-    while not (ret and pred == nil) and i <= mot:len() do
+    -- 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 string.byte(pred) == (string.byte(c) - 1) 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
@@ -33,17 +48,18 @@ local function suite(mot)
         end
         i = i + 1
     end
-    if ret and pred == nil then
-        return true
-    else
-        return false
-    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
@@ -54,17 +70,23 @@ local function double(mot)
     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(string.byte(ret:sub(tmp, tmp)) + 1) .. string.rep('a', ret:len() - tmp)
+            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(string.byte(ret:sub(tmp, tmp)) + 1)
+            ret = ret:sub(1, tmp-1) .. string.char(ret:sub(tmp, tmp):byte() + 1)
         else
-            ret = ret:sub(1, tmp - 1) .. string.char(string.byte(ret:sub(tmp, tmp)) + 1) .. string.rep('a', ret:len() - tmp)
+            ret = ret:sub(1, tmp - 1) .. string.char(ret:sub(tmp, tmp):byte() + 1) .. string.rep('a', #ret - tmp)
         end
     end
     return ret
@@ -84,8 +106,3 @@ while not fin do
         myInput = suivant(myInput)
     end
 end
-
-
--- une suite de 3 caractères au moins (abc par ex)
--- ne doit pas contenir i l o
--- doit avoir 2 doubles (aa et cc par ex)