/*""" Übung1_Nummern auffüllen - Lösungsvorschläge Autor: jthi Erstellungsdatum: 05.01.2024 Erstellung JMP-Version: JMP Pro 17.2 Beschreibung: Finden Sie heraus, wie Sie mithilfe der Zeichendarstellung Zahlen so auffüllen, dass die Zahlen immer drei Zeichen lang sind. Testen Sie mit Werten zwischen 0 und 999. Hinweis: Ziel ist nicht, eine Funktion zur Durchführung dieser Aufgabe zu erstellen. Sie können natürlich eine Funktion erstellen oder Ausdrücke verwenden, aber das haben wir in diesem Kurs noch nicht behandelt. Beispiele: Eingabe Ausgabe 1 "001" 10 "010" 100 "100" Bonus 1: Wenn der Wert kleiner als 0 oder größer als 999 ist, setzen Sie den Wert als leeren String. Bonus 2: Finden Sie mindestens eine weitere Methode zur Durchführung dieser Aufgabe. Extra: Führen Sie eine ähnliche Berechnung in einer Datentabelle durch und erstellen Sie eine neue Spalte """*/ //=========================================================== // Eingabe //= ... // Sie können Ihre eigenen Beispiele erstellen //============================================================= // Schritt-für-Schritt-Lösung //=========================================================== // Hinweis: Alle Werte liegen zwischen 0 und 999 (fehlende Werte ODER Werte über 1000 müssen sich keine Gedanken machen) // Beginnen Sie mit kleinen, sehr einfachen Teilen // in dieser Schritt-für-Schritt-Lösung gehen wir davon aus, dass die maximale Anzahl an Nullen, die wir hinzufügen, 2 ist val = 1; val_str = Char(val); // in Zeichenfolge ändern res1 = "00" || val_str; // "001" -> OK -> keine zu entfernenden Nullen val2 = 10; val_str2 = Char(val2); // in String ändern res2 = "00" || val_str2; // "0010" -> NOK -> Wir müssen EINE Null entfernen val3 = 100; val_str3 = Char(val3); // in String ändern res3 = "00" || val_str3; // "00010" -> NOK -> Wir müssen ZWEI Nullen entfernen // Erstellen Sie eine einfache Schleife, um das Testen zu vereinfachen For Each({val}, input_list, val_str = Char(val); res = "00" || val_str; Print(Eval Insert("Input: ¤val¤, Result: ¤res¤", "¤")); ); // wie können wir die richtige Anzahl von Nullen hinzufügen? // wir könnten die Anzahl der Nullen auf der Länge von val_str basieren // Länge 1 -> 2 hinzufügen // Länge 2 -> 1 hinzufügen // Länge 3 -> 0 hinzufügen len_val = Length(val_str); // Wir könnten If, Match oder Choose verwenden zeros_to_add = If(len_val == 1, 2 , len_val == 2, 1 , len_val == 3, // könnten dafür auch einfach else verwenden 0 ); zeros_to_add = Match(len_val, 1, 2, 2, 1, 3, 0 ); zeros_to_add = Choose(len_val, 2, 1, 0 ); // oder allgemeinere Lösung // wenn die Länge um 1 zunimmt, verringern sich die hinzugefügten Nullen um 1, BEGINNEND bei 2 zeros_to_add = 3 - len_val; // Mindestlänge ist 1 -> beginne mit der Addition bei 3 // wir können dies mit einer Schleife testen (in der nächsten Lektion können wir es in eine Funktion umwandeln, um es noch einfacher zu machen) For Each({val}, input_list, val_str = Char(val); zeros_to_add = 3 - Length(val_str); show(zeros_to_add); ); // jetzt wissen wir, wie viele Nullen hinzugefügt werden müssen. Wie werden sie erstellt? // Wiederholen ist eine gute 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); // und jetzt erstellen wir unseren endgültigen String val_output = zero_str || val_str; // Test mit Schleife 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); ); // in Lösung umwandeln (Liste von Zeichenfolgen) 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); //============================================================ // Nicht schrittweise Lösungen //======================================================== //============================================================== // Option 1 - Nullen hinzufügen und jeweils transformieren //============================================================== input_list = {1, 10, 100}; MAX_STRING_LENGTH = 3; Ergebnis = 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; // letzte Zeile wird von Transform Each zurückgegeben); show(result); //============================================================== // Option 2 – Nullen mit „Rechts“ entfernen //======================================================== input_list = {1, 10, 100}; // wir wissen, dass die maximale Anzahl an Nullen 2 ist -> wir können unseren String vorher erstellen MAX_STR_LENGTH = 3; zero_str = Repeat("0", MAX_STR_LENGTH - 1); // -1, um Platz für unser Zahlenergebnis zu lassen = Transform Each({val}, input_list, val_str = Char(val); Right(zero_str || val_str, MAX_STR_LENGTH); ); show(result); //============================================================= // Option 3 – Nullen mit Substr entfernen //============================================================ input_list = {1, 10, 100}; MAX_ZERO_STR = "00"; Ergebnis = 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); // sollte auch funktionieren ); show(Ergebnis); //============================================================== // Option 4 – Regulärer Ausdruck (in einfachen Fällen wie diesem nicht wirklich zu empfehlen) //============================================================ 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; Regex(res_str, "\d{3}$"); // nehme die letzten drei Zahlen ); show(result); //============================================================== // Option 5 – Nicht tun //=========================================================== input_list = {1, 10, 100}; result = Transform Each({val}, input_list, str = Char(val, 4, 3); // Stringbreite ist 4, um Dezimaltrennzeichen zu berücksichtigen str_l = Words(str, ".,"); Concat Items(Reverse(str_l), ""); ); show(result); //============================================================= // Bonus 1 – Option 1 verwenden //========================================================= input_list = {1, 10, 100, -1, 1000, 0, ., 99, 10, 999, 9}; MAX_STRING_LENGTH = 3; Ergebnis = Transform Each({val}, Eingabeliste, Wenn(!IsMissing(val) & 0 < val < 1000, val_str = Char(val); Zeros_to_add = MAX_STRING_LENGTH - Length(val_str); Wiederholen("0", Zeros_to_add) || val_str; // letzte Zeile wird von Transform Each zurückgegeben, // sonst ""; ); ); anzeigen(Ergebnis); //============================================================= // Bonus 1 (nicht funktionierende Lösung) – Debugging-Skript mit Try-Catch //=========================================================== input_list = {1, 10, 100, -1, 1000, 0, .}; MAX_STRING_LENGTH = 3; Ergebnis = Transform Each({val}, Eingabeliste, 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; // letzte Zeile wird von Transform Each zurückgegeben, // sonst ""; ); , Show(val, exception_msg); // nützlich, um den Wert auszudrucken, da Sie ihn dann testen können ); ); show(Ergebnis); //============================================================== // Bonus 1 – Nur gültige Optionen zu einer Liste hinzufügen und eine Liste mit Problemen zurückgeben //============================================================== // wir ändern es zu For Each, da die Verwaltung der Rückgabewerte auf diese Weise viel einfacher ist input_list = {1, 10, 100, -1, 1000, 0, .}; MAX_STRING_LENGTH = 3; result = {}; issue_list = {}; // Liste von Listen mit Index und Wert speichern aa_issues = Associative Array(); // andere Option (verwende idx als Schlüssel und value als Wert) 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; // letzte Zeile wird von Transform Each Insert Into(result, res); zurückgegeben, // sonst Insert Into(issue_list, Eval List({Eval List({idx, val})})); aa_issues[idx] = val; // andere Option ); , // catch Show(val, exception_msg); ); ); show(result, issue_list, aa_issues); //============================================================== // Erstellen Sie zusätzlich eine Formel, um eine ähnliche Aktion auszuführen //= ... //============================================================== // Verwenden einer einfachen Formel mit fest codierten Werten //==================================================================== dt_input << New Column("Solution1", Character, Nominal, Formula( Right("00" || Char(:Input), 3); )); //============================================================= // Verwenden von Local() und Variablen //====================================================================== dt_input << New Column("Solution2", Character, Nominal, Formula( Local({ MAX_STR_LENGTH = 3, zero_str = Repeat("0", MAX_STR_LENGTH - 1) }, Right(zero_str || Char(:Input), MAX_STR_LENGTH); ); )); //============================================================= // Verwenden von As Constant() //============================================================= // Variablen sollten bei Verwendung von dt_input nur in der ersten Zeile ausgewertet werden << 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); )); //============================================================ // Tabellenvariable verwenden //= ... dt_input << New Column("Solution4", Character, Nominal, Formula( Right(Repeat("0", Num(:MAX_INPUT_LENGTH) - 1) || Char(:Input), Num(:MAX_INPUT_LENGTH)); )); // Hinweis: Um sicherzustellen, dass die Formeln ausgewertet wurden, verwenden Sie dt_ref << Run Formulas; NICHT wait(0); // Hinweis: Bei der Verwendung von Formeln kann es sinnvoll sein, diese entweder zu entfernen ODER ihre Auswertung zu unterdrücken, // wenn die Werte nach der ersten Erstellung nicht aktualisiert werden müssen. // col_ref << Delete Formula; // col_ref << Suppress Eval(1); //============================================================ // Verwenden von „For Each Row“ anstelle einer Formel //============================================================= // wenn Sie sich bezüglich des Spaltennamens sicher sind, dt_input << New Column("Solution5", Character, Nominal); For Each Row(dt_input, :Solution5 = Right("00" || Char(:Input), 3); ); // wenn nicht, können Sie die Spaltenreferenz verwenden, new_col = dt_input << New Column("Solution5.1", Character, Nominal); For Each Row(dt_input, new_col[Row()] = Right("00" || Char(:Input), 3); // könnte auch :Solution5 verwenden); // oder mit Spaltennamen new_col = dt_input << New Column("Solution5.2", Character, Nominal); For Each Row(dt_input, As Column(dt_input, (new_col << get name)) = Right("00" || Char(:Input), 3); ); // oder mit Spaltennamen new_col = dt_input << New Column("Solution5.3", Character, Nominal); For Each Row(dt_input, Column(dt_input, (new_col << get name))[] = Right("00" || Char(:Input), 3); ); // Beachten Sie, wie [] und [Row()] verwendet werden (sie sind dasselbe, aber [Row()] ist expliziter) //============================================================ // Verwenden von << Set Each Value (DIES IST NICHT DAS VORGESEHENE VERHALTEN, DAHER KANN ES SICH ÄNDERN) //
https://community.jmp.com/t5/JMP-Wish-List/Make-using-formula-expressions-in-Set-Each-Value-and-using/idi-p/666966 //====================================================================================== Spalte("Lösung6", Zeichen, Nominal, << Setze jeden Wert( Rechts("00" || Zeichen(:Eingabe), 3); )); Schreiben();
