/*""" Exercice 1_Remplissage_nombres suggestions de solutions Auteur : jthi Date de création : 2024-01-05 Création JMP Version : JMP Pro 17.2 Description : Découvrez comment ajouter un remplissage aux nombres en utilisant la présentation des caractères de telle sorte que les nombres comportent toujours trois caractères. Testez avec des valeurs entre 0 et 999. Remarque : Le but n'est pas de créer une fonction pour effectuer cette tâche. Vous pouvez bien sûr créer une fonction ou utiliser des expressions, mais nous ne les avons pas encore abordées dans ce cours. Exemples : Entrée Sortie 1 "001" 10 "010" 100 "100" Bonus 1 : Si la valeur est inférieure à 0 ou supérieure à 999, définissez la valeur comme une chaîne vide Bonus 2 : Trouvez au moins une méthode supplémentaire pour effectuer cette même tâche Bonus : Effectuez un calcul similaire sur une table de données et créez une nouvelle colonne """*/ //=============================================================== // Entrée //============================================================= Noms par défaut ici(1); input_list = {1, 10, 100}; // vous pouvez créer vos propres exemples //=============================================================== // Solution étape par étape //=============================================================== // Remarque : toutes les valeurs sont comprises entre 0 et 999 (pas besoin de s'inquiéter des valeurs manquantes OU des valeurs supérieures ou égales à 1 000) // Commencez par de petits morceaux très simples // dans cette solution étape par étape, nous supposons que le nombre maximal de zéros que nous ajoutons est de 2 val = 1; val_str = Char(val); // changer en chaîne res1 = "00" || val_str; // "001" -> OK -> aucun zéro à supprimer val2 = 10; val_str2 = Char(val2); // changer en chaîne res2 = "00" || val_str2; // "0010" -> NOK -> Nous devons supprimer UN zéro val3 = 100; val_str3 = Char(val3); // changer en chaîne res3 = "00" || val_str3; // "00010" -> NOK -> Nous devons supprimer DEUX zéros // Créer une boucle de base pour faciliter les tests For Each({val}, input_list, val_str = Char(val); res = "00" || val_str; Print(Eval Insert("Input: ¤val¤, Result: ¤res¤", "¤")); ); // comment pouvons-nous ajouter la bonne quantité de zéros ? // nous pourrions baser la quantité de zéros sur la longueur de val_str // longueur 1 -> ajouter 2 // longueur 2 -> ajouter 1 // longueur 3 -> ajouter 0 len_val = Length(val_str); // Nous pourrions utiliser If, Match ou Choose zeros_to_add = If(len_val == 1, 2 , len_val == 2, 1 , len_val == 3, // nous pourrions aussi simplement utiliser else pour cela 0 ); zeros_to_add = Match(len_val, 1, 2, 2, 1, 3, 0 ); zeros_to_add = Choose(len_val, 2, 1, 0 ); // ou une solution plus générique // lorsque la longueur augmente de 1, les zéros ajoutés diminuent de 1 À PARTIR de 2 zeros_to_add = 3 - len_val; // la longueur minimale est de 1 -> commencer par l'addition à partir de 3 // nous pouvons les tester avec une boucle (dans la prochaine leçon, nous pouvons la transformer en fonction pour la rendre encore plus facile) For Each({val}, input_list, val_str = Char(val); zeros_to_add = 3 - Length(val_str); show(zeros_to_add); ); // maintenant nous savons combien de zéros ajouter. Comment les créer ? // Répéter est une bonne option val = 1; val_str = Char(val); len_val = Length(val_str); zeros_to_add = 3 - len_val; zero_str = Repeat("0", zeros_to_add); // et maintenant nous créons notre chaîne finale val_output = zero_str || val_str; // tester avec une boucle For Each({val}, input_list, val_str = Char(val); len_val = Length(val_str); zeros_to_add = 3 - len_val; zero_str = Repeat("0", zeros_to_add); val_output = zero_str || val_str; show(val_output); ); // transformer en solution (liste de chaînes) result = {}; For Each({val}, input_list, val_str = Char(val); len_val = Length(val_str); zeros_to_add = 3 - len_val; zero_str = Repeat("0", zeros_to_add); val_output = zero_str || val_str; Insert Into(result, val_output); ); show(result); //================================================================== // Solutions non étape par étape //============================================================================== //================================================================== // Option 1 - Ajouter des zéros et utiliser la transformation each //===================================================================== input_list = {1, 10, 100}; MAX_STRING_LENGTH = 3; result = Transform Each({val}, input_list, val_str = Char(val); zeros_to_add = MAX_STRING_LENGTH - Length(val_str); Repeat("0", zeros_to_add) || val_str; // la dernière ligne sera renvoyée par Transform Each ); show(result); //=============================================================== // Option 2 - Supprimer les zéros en utilisant Right //================================================================ input_list = {1, 10, 100}; // nous savons que le nombre maximum de zéros que nous pouvons avoir est de 2 -> nous pouvons créer notre chaîne au préalable MAX_STR_LENGTH = 3; zero_str = Repeat("0", MAX_STR_LENGTH - 1); // -1 pour laisser de la place à notre nombre result = Transform Each({val}, input_list, val_str = Char(val); Right(zero_str || val_str, MAX_STR_LENGTH); ); show(result); //=============================================================== // Option 3 - Supprimer les zéros à l'aide de Substr //=============================================================== input_list = {1, 10, 100}; MAX_ZERO_STR = "00"; result = Transform Each({val}, input_list, val_str = Char(val); res_str = MAX_ZERO_STR || val_str; start_idx = Length(res_str) - 2; Substr(res_str, start_idx); // Substr(res_str, start_idx, Length(res_str)); // Substr(res_str, -3); // devrait aussi fonctionner ); show(result); //=============================================================== // Option 4 - Regex (pas vraiment recommandée dans un cas simple comme celui-ci) //================================================================ input_str = {1, 10, 100}; MAX_ZERO_STR = "00"; result = Transform Each({val}, input_list, val_str = Char(val); res_str = MAX_ZERO_STR || val_str; Regex(res_str, "\d{3}$"); // prendre les trois derniers nombres ); show(result); //=============================================================== // Option 5 - Ne pas faire cela //============================================================= input_list = {1, 10, 100}; result = Transform Each({val}, input_list, str = Char(val, 4, 3); // la largeur de la chaîne est de 4 pour prendre en compte le séparateur décimal str_l = Words(str, ".,"); Concat Items(Reverse(str_l), ""); ); show(result); //=============================================================== // Bonus 1 - Utilisation de l'option 1 //=============================================================== input_list = {1, 10, 100, -1, 1000, 0, ., 99, 10, 999, 9}; MAX_STRING_LENGTH = 3; result = Transform Each({val}, input_list, If(!IsMissing(val) & 0 < val < 1000, val_str = Char(val); zeros_to_add = MAX_STRING_LENGTH - Length(val_str); Repeat("0", zeros_to_add) || val_str; // la dernière ligne sera renvoyée par Transform Each , // else ""; ); ); show(result); //=============================================================== // Bonus 1 (solution non fonctionnelle) - Script de débogage utilisant Try-Catch //=============================================================== input_list = {1, 10, 100, -1, 1000, 0, .}; MAX_STRING_LENGTH = 3; result = Transform Each({val}, input_list, Try( If(!IsMissing(val) | 0 < val < 1000, val_str = Char(val); zeros_to_add = MAX_STRING_LENGTH - Length(val_str); Repeat("0", zeros_to_add) || val_str; // la dernière ligne sera renvoyée par Transform Each , // else ""; ); , Show(val, exception_msg); // utile pour imprimer la valeur car vous pouvez ensuite tester avec ); ); show(result); //============================================================ // Bonus 1 - Ajouter uniquement les options valides à une liste et renvoyer la liste des problèmes //================================================================== // nous passons à For Each car la gestion de ce qui est renvoyé est beaucoup plus facile de cette façon input_list = {1, 10, 100, -1, 1000, 0, .}; MAX_STRING_LENGTH = 3; result = {}; issue_list = {}; // stocker la liste des listes avec l'index et la valeur aa_issues = Associative Array(); // autre option (utiliser idx comme clé et valeur comme valeur) For Each({val, idx}, input_list, Try( If(!IsMissing(val) & 0 < val < 1000, val_str = Char(val); zeros_to_add = MAX_STRING_LENGTH - Length(val_str); res = Repeat("0", zeros_to_add) || val_str; // la dernière ligne sera renvoyée par Transform Each Insert Into(result, res); , // else Insert Into(issue_list, Eval List({Eval List({idx, val})})); aa_issues[idx] = val; // autre option ); , // catch Show(val, exception_msg); ); ); show(result, issue_list, aa_issues); //=============================================================== // Supplémentaire, créez une formule pour effectuer une action similaire //=============================================================== dt_input = New Table("Exercise1_Padding_Solution", Add Rows(1000), Compress File When Saved(1), New Column("Input", Numeric, "Continuous", Set Values(0::999)) ); //=============================================================== // Utilisation d'une formule simple avec des valeurs codées en dur //=============================================================== dt_input << New Column("Solution1", Character, Nominal, Formula( Right("00" || Char(:Input), 3); )); //=============================================================== // Utilisation de Local() et des variables //=============================================================== dt_input << Nouvelle colonne("Solution2", Caractère, Nominal, Formule( Local({ MAX_STR_LENGTH = 3, zero_str = Repeat("0", MAX_STR_LENGTH - 1) }, Right(zero_str || Char(:Input), MAX_STR_LENGTH); ); )); //=============================================================== // Utilisation de As Constant() //================================================================== // les variables doivent être évaluées uniquement sur la première ligne lors de l'utilisation de ce dt_input << New Column("Solution3", Character, Nominal, Formula( As Constant( MAX_STR_LENGTH = 3; zero_str = Repeat("0", MAX_STR_LENGTH - 1); ); Right(zero_str || Char(:Input), MAX_STR_LENGTH); )); //=============================================================== // Utilisation d'une variable de table //================================================================== dt_input << New Table Variable("MAX_INPUT_LENGTH", 3); // Les variables de table sont stockées sous forme de chaînes, je les convertirais donc juste pour être sûr // dt_input << Get Table Variable("MAX_INPUT_LENGTH"); dt_input << New Column("Solution4", Character, Nominal, Formula( Right(Repeat("0", Num(:MAX_INPUT_LENGTH) - 1) || Char(:Input), Num(:MAX_INPUT_LENGTH)); )); // Remarque : pour vous assurer que les formules ont été évaluées, utilisez dt_ref << Run Formulas; PAS wait(0); // Remarque : lorsque vous utilisez des formules, il peut être judicieux de les supprimer OU de supprimer leur évaluation // s'il n'est pas nécessaire de mettre à jour les valeurs après la création initiale // col_ref << Delete Formula; // col_ref << Suppress Eval(1); //=============================================================== // Utilisation de For Each Row au lieu de la formule //================================================================== // Si vous êtes sûr du nom de la colonne dt_input << New Column("Solution5", Character, Nominal); For Each Row(dt_input, :Solution5 = Right("00" || Char(:Input), 3); ); // Si vous ne l'êtes pas, vous pouvez utiliser la référence de colonne new_col = dt_input << New Column("Solution5.1", Character, Nominal); For Each Row(dt_input, new_col[Row()] = Right("00" || Char(:Input), 3); // Vous pouvez également utiliser :Solution5 ); // ou avec le nom de colonne new_col = dt_input << New Column("Solution5.2", Character, Nominal); Pour chaque ligne(dt_input, comme colonne(dt_input, (new_col << get name)) = Right("00" || Char(:Input), 3); ); // ou avec le nom de colonne new_col = dt_input << New Column("Solution5.3", Character, Nominal); Pour chaque ligne(dt_input, colonne(dt_input, (new_col << get name))[] = Right("00" || Char(:Input), 3); ); // notez comment [] et [Row()] sont utilisés (c'est la même chose mais [Row()] est plus explicite) //=============================================================== // Utilisation de << Définir chaque valeur (CECI N'EST PAS UN COMPORTEMENT PRÉVU, CELA PEUT DONC CHANGER) //
https://community.jmp.com/t5/JMP-Wish-List/Make-using-formula-expressions-in-Set-Each-Value-and-using/idi-p/666966 //=============================================================== dt_input << New Column("Solution6", Character, Nominal, << Définir chaque valeur( Right("00" || Char(:Input), 3); )); Write();
