Upload 136 files

.gitattributes

@@ -26,7 +26,6 @@
 *.safetensors filter=lfs diff=lfs merge=lfs -text
 saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
 *.tflite filter=lfs diff=lfs merge=lfs -text
 *.tgz filter=lfs diff=lfs merge=lfs -text
 *.wasm filter=lfs diff=lfs merge=lfs -text
@@ -53,3 +52,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
+AndroidML.docx filter=lfs diff=lfs merge=lfs -text
+docs-readthedocs-io-en-stable.epub filter=lfs diff=lfs merge=lfs -text
+index.duckdb filter=lfs diff=lfs merge=lfs -text
+sumarabic-1.0-index.jsonl filter=lfs diff=lfs merge=lfs -text

Additional algorithm 1.cpp

@@ -0,0 +1,11 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 1. It shows the “Hello world” example for all computer languages used in this work. This is intended as a positive first introduction. Note that the source code is in context and works with copy/paste.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    cout<<"Hello World";
+    return 0;
+}

Additional algorithm 1.py

@@ -0,0 +1,4 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 1. It shows the “Hello world” example for all computer languages used in this work. This is intended as a positive first introduction. Note that the source code is in context and works with copy/paste.
+
+print ('Hello World')

Additional algorithm 10.cpp

@@ -0,0 +1,4 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 10. Example of interesting evaluations in PERL showing that concatenations that use the "+" operator instead of the "." operator, lead to the elimination of the string value from the result, with no error in sight. Note that the source code is out of context and is intended for explanation of the method.
+
+// this example is only for PERL

Additional algorithm 10.py

@@ -0,0 +1,4 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 10. Example of interesting evaluations in PERL showing that concatenations that use the "+" operator instead of the "." operator, lead to the elimination of the string value from the result, with no error in sight. Note that the source code is out of context and is intended for explanation of the method.
+
+# this example is only for PERL

Additional algorithm 11.cpp

@@ -0,0 +1,15 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 11. It shows how constants are declared in different computer languages. Moreover, it shows the difference between constant declaration (second column) and variable declaration (third column). Some computer languages use special keywords and data type declarations, while other computer languages do not. Notice how in certain computer languages where there are no special keywords for defining constants, the difference between constant and variable is made by convention; namely a variable written with an uppercase letter means a constant and a variable written with a lowercase letter means a simple variable whose content can be changed at will. Note that the source code is out of context and is intended for explanation of the method.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    const float a = 3.1415926535;
+    float b = 3.1415926535897932;
+    
+    cout<<(a+b);
+    
+    return 0;
+}

Additional algorithm 11.py

@@ -0,0 +1,7 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 11. It shows how constants are declared in different computer languages. Moreover, it shows the difference between constant declaration (second column) and variable declaration (third column). Some computer languages use special keywords and data type declarations, while other computer languages do not. Notice how in certain computer languages where there are no special keywords for defining constants, the difference between constant and variable is made by convention; namely a variable written with an uppercase letter means a constant and a variable written with a lowercase letter means a simple variable whose content can be changed at will. Note that the source code is out of context and is intended for explanation of the method.
+
+X = 3.14159265358979323846264 # uppercase signifies the role of a constant
+x = 3.14159265358979323846264
+
+print (x + X)

Additional algorithm 12.cpp

@@ -0,0 +1,14 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 12. It shows two methods of declaring an empty array. For declaration purposes, computer languages use either square brackets or round brackets to indicate that the variable represents a group of "internal subvariables". On the second column is the array square parentheses type of declaration. On the third column is the array constructor type of declaration. Most computer languages that use the array constructor statement are usually object-oriented. But not all of them; for example Python does not have a special keyword of this kind, preferring the array square parentheses notation. Those declarations that explicitly write the data type for the array, can obviously take any data type. Here the example was given on a string data type for computer languages such as Java, C# and VB. Note that the source code is out of context and is intended for explanation of the method.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    string A[0];
+    //or
+    //string *A = new string[0];
+    
+    return 0;
+}

Additional algorithm 12.py

@@ -0,0 +1,4 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 12. It shows two methods of declaring an empty array. For declaration purposes, computer languages use either square brackets or round brackets to indicate that the variable represents a group of "internal subvariables". On the second column is the array square parentheses type of declaration. On the third column is the array constructor type of declaration. Most computer languages that use the array constructor statement are usually object-oriented. But not all of them; for example Python does not have a special keyword of this kind, preferring the array square parentheses notation. Those declarations that explicitly write the data type for the array, can obviously take any data type. Here the example was given on a string data type for computer languages such as Java, C# and VB. Note that the source code is out of context and is intended for explanation of the method.
+
+A = []

Additional algorithm 13.cpp

@@ -0,0 +1,16 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 13. It shows how to create a multi-valued one-dimensional array variable using literals. In this example an array variable A is used to store only string literals and an array variable B is used to store integer literals. In languages such as Javascript, PHP, PERL, Ruby or Python, array variables can store several types of literals, including objects. In languages such as Java, C# and VB, array variables can store only one type of literal. Note that the source code is in context and works with copy/paste.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    string A[] = {"a", "b", "c"};
+    int B[] = {1, 2, 3};
+    
+    cout<<(A[0] + A[1] + A[2]);
+    cout<<(B[0] + B[1] + B[2]);
+
+    return 0;
+}

Additional algorithm 13.py

@@ -0,0 +1,8 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 13. It shows how to create a multi-valued one-dimensional array variable using literals. In this example an array variable A is used to store only string literals and an array variable B is used to store integer literals. In languages such as Javascript, PHP, PERL, Ruby or Python, array variables can store several types of literals, including objects. In languages such as Java, C# and VB, array variables can store only one type of literal. Note that the source code is in context and works with copy/paste.
+
+A = ["a", "b", "c"]
+B = [1, 2, 3]
+
+print (A[0] + A[1] + A[2])
+print (B[0] + B[1] + B[2])

Additional algorithm 14.cpp

@@ -0,0 +1,18 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 14. It shows the statements by which an array variable A is declared and the statements by which literal values are subsequently inserted into the elements of the array variable. It should be noted that some computer languages such as Javascript, PHP, PERL or Ruby allow the declaration of an empty array variable, after which the values can be inserted into newly declared elements. On the other hand, in other computer languages such as C#, Java, VB and Python, the number of elements in the array variable must be declared before the assignment of values. Note that the source code is in context and works with copy/paste.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    string A[3];
+    
+    A[0] = "a";
+    A[1] = "b";
+    A[2] = "c";
+    
+    cout<<(A[0] + A[1] + A[2]);
+
+    return 0;
+}

Additional algorithm 14.py

@@ -0,0 +1,10 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 14. It shows the statements by which an array variable A is declared and the statements by which literal values are subsequently inserted into the elements of the array variable. It should be noted that some computer languages such as Javascript, PHP, PERL or Ruby allow the declaration of an empty array variable, after which the values can be inserted into newly declared elements. On the other hand, in other computer languages such as C#, Java, VB and Python, the number of elements in the array variable must be declared before the assignment of values. Note that the source code is in context and works with copy/paste.
+
+A = [0]*3
+
+A[0] = "a"
+A[1] = "b"
+A[2] = "c"
+
+print (A[0] + A[1] + A[2])

Additional algorithm 15.cpp

@@ -0,0 +1,17 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 15. It shows how to access the values stored in the elements of an array variable. An array literal is declared, in which three string values (three separate characters, namely "a", "b", "c") are stored. Then, two variables x and y are declared, which take values from the elements of the array variable A. Then, once assigned to the x and y variables, the string values are displayed in the output for visualization. As it can be observed, the result obtained after the execution is "bc". Note that the source code is in context and works with copy/paste.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    string A[] = {"a", "b", "c"};
+    
+    string x = A[1];
+    string y = A[2];
+    
+    cout<<(x + y);
+
+    return 0;
+}

Additional algorithm 15.py

@@ -0,0 +1,9 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 15. It shows how to access the values stored in the elements of an array variable. An array literal is declared, in which three string values (three separate characters, namely "a", "b", "c") are stored. Then, two variables x and y are declared, which take values from the elements of the array variable A. Then, once assigned to the x and y variables, the string values are displayed in the output for visualization. As it can be observed, the result obtained after the execution is "bc". Note that the source code is in context and works with copy/paste.
+
+A = ["a", "b", "c"]
+
+x = A[1]
+y = A[2]
+
+print (x + y)

Additional algorithm 16.cpp

@@ -0,0 +1,21 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 16. It shows how to change values in existing array elements. An array variable A is declared. String literals are assigned to each element of A. The value from the first element of the array variable A, is assigned to a variable x. Then, a literal string value (ie. "d") is assigned to the second element of variable array A, thus erasing the previous value (ie. "a") from this element. Next, the value from the third element of A is assigned to the second element of A, thus deleting the initial value (ie. "b") from the second element. The value stored in variable x is assigned to the third element of array A. At the end, the values from each element are displayed in the output for inspection. Here, the initial sequence "abc" was transformed into the sequence "dcb". Note that the source code is in context and works with copy/paste.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    string A[] = {"a", "b", "c"};
+    string x;
+    
+    x = A[1];
+
+    A[0] = "d";
+    A[1] = A[2];
+    A[2] = x;
+
+    cout<<(A[0] + A[1] + A[2]);
+
+    return 0;
+}

Additional algorithm 16.py

@@ -0,0 +1,12 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 16. It shows how to change values in existing array elements. An array variable A is declared. String literals are assigned to each element of A. The value from the first element of the array variable A, is assigned to a variable x. Then, a literal string value (ie. "d") is assigned to the second element of variable array A, thus erasing the previous value (ie. "a") from this element. Next, the value from the third element of A is assigned to the second element of A, thus deleting the initial value (ie. "b") from the second element. The value stored in variable x is assigned to the third element of array A. At the end, the values from each element are displayed in the output for inspection. Here, the initial sequence "abc" was transformed into the sequence "dcb". Note that the source code is in context and works with copy/paste.
+
+A = ["a", "b", "c"]
+
+x = A[1]
+
+A[0] = "d"
+A[1] = A[2]
+A[2] = x
+
+print (A[0] + A[1] + A[2])

Additional algorithm 17.cpp

@@ -0,0 +1,16 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 17. It shows how to get the total number of elements of an array. First an array literal A is declared, that contains three elements, each with a string literal (one character). Next, a variable x is declared and a value is assigned to it. The value in question represents the number of elements in array A and is provided either by an in-built function or by a method of the array object, depending on the computer language used. Finally, the content of variable x is displayed in the output for inspection. One thing to note is that in VB, the ubound internal function returns the last index in the array and not the total number of elements as expected from the other examples. Note that the source code is in context and works with copy/paste.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    string A[] = {"a", "b", "c"};
+
+    int x = sizeof(A) / sizeof(string);
+
+    cout<<x;
+
+    return 0;
+}

Additional algorithm 17.py

@@ -0,0 +1,8 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 17. It shows how to get the total number of elements of an array. First an array literal A is declared, that contains three elements, each with a string literal (one character). Next, a variable x is declared and a value is assigned to it. The value in question represents the number of elements in array A and is provided either by an in-built function or by a method of the array object, depending on the computer language used. Finally, the content of variable x is displayed in the output for inspection. One thing to note is that in VB, the ubound internal function returns the last index in the array and not the total number of elements as expected from the other examples. Note that the source code is in context and works with copy/paste.
+
+A = ["a", "b", "c"]
+
+x = len(A)
+
+print(x)

Additional algorithm 18.cpp

@@ -0,0 +1,4 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 18. It presents nested arrays in Javascript, Ruby and Python. Three array variables A, B and C are declared here, each with three literal values. To represent the notion of nested, three other array variables are declared, namely D, E and F, each with three elements that hold one of the arrays A, B or C. To provide yet another level in the nest, a last three-element array variable is declared (ie. G), in which each element takes one of the recently mentioned arrays (ie. D, E or F). Note that the source code is in context and works with copy/paste.
+
+// this example was given for Javascript, Python and Ruby.

Additional algorithm 18.py

@@ -0,0 +1,16 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 18. It presents nested arrays in Javascript, Ruby and Python. Three array variables A, B and C are declared here, each with three literal values. To represent the notion of nested, three other array variables are declared, namely D, E and F, each with three elements that hold one of the arrays A, B or C. To provide yet another level in the nest, a last three-element array variable is declared (ie. G), in which each element takes one of the recently mentioned arrays (ie. D, E or F). Note that the source code is in context and works with copy/paste.
+
+A = ["a", "b", "c"]
+B = ["d", "e", "f"]
+C = ["g", "h", "i"]
+
+D = [A, B, C]
+E = [B, C, A]
+F = [C, B, A]
+
+G = [D, E, F]
+
+print (A[0])
+print (D[0])
+print (G[0])

Additional algorithm 19.py

@@ -0,0 +1,9 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 19. It shows the way in which multidimensional array variables can be declared. An interesting difference can be observed between two groups of computer languages. A group involving Javascript, PHP, PERL, Ruby or Python and another group involving classic computer languages, namely C#, Java, VB. The first group (ie. Javascript, PHP, PERL, Ruby or Python) uses largely the same type of declaration for several dimensions. The Javascript example shows how to declare two-dimensional and three-dimensional array variables, where the pattern can be followed for any higher dimensions (ie. 4D, 5D, 6D, and so on). In PHP, PERL, Ruby or Python, the exemplification is only repeated for two dimensions and it assumes that for more than two dimensions the declarations can be made in the same way as in Javascript. The second group is more different, where Java, C# and VB are radically different in the way statements are made. Obviously, Java and C# have common syntax elements, but they differ a little in the way the declarations for arrays are made. In VB, the number of dimensions and the number of elements in each dimension are initially declared. Only then these elements in their respective dimensions can receive values by assignment. VB is so radically different when compared to other computer languages, that array variables have a lower bound (read through the LBound function) and an upper bound (read through the UBound function), a property that can open paths in prototyping (especially in science). In the VB examples, each Debug.Print statement line corresponds to a row in the output. Note that the source code is in context and works with copy/paste.
+
+A = [["a", 88, 146],
+     ["b", 34, 124],
+     ["c", 96, 564],
+     [100, 12, "d"]]
+
+print(A[1][2])

Additional algorithm 19a.cpp

@@ -0,0 +1,17 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 19. It shows the way in which multidimensional array variables can be declared. An interesting difference can be observed between two groups of computer languages. A group involving Javascript, PHP, PERL, Ruby or Python and another group involving classic computer languages, namely C#, Java, VB. The first group (ie. Javascript, PHP, PERL, Ruby or Python) uses largely the same type of declaration for several dimensions. The Javascript example shows how to declare two-dimensional and three-dimensional array variables, where the pattern can be followed for any higher dimensions (ie. 4D, 5D, 6D, and so on). In PHP, PERL, Ruby or Python, the exemplification is only repeated for two dimensions and it assumes that for more than two dimensions the declarations can be made in the same way as in Javascript. The second group is more different, where Java, C# and VB are radically different in the way statements are made. Obviously, Java and C# have common syntax elements, but they differ a little in the way the declarations for arrays are made. In VB, the number of dimensions and the number of elements in each dimension are initially declared. Only then these elements in their respective dimensions can receive values by assignment. VB is so radically different when compared to other computer languages, that array variables have a lower bound (read through the LBound function) and an upper bound (read through the UBound function), a property that can open paths in prototyping (especially in science). In the VB examples, each Debug.Print statement line corresponds to a row in the output. Note that the source code is in context and works with copy/paste.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    int A[][2] = {{1,2},
+                  {3,4},
+                  {5,6},
+                  {7,8}};
+
+    cout<<A[0][1];
+    
+    return 0;
+}

Additional algorithm 19b.cpp

@@ -0,0 +1,19 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 19. It shows the way in which multidimensional array variables can be declared. An interesting difference can be observed between two groups of computer languages. A group involving Javascript, PHP, PERL, Ruby or Python and another group involving classic computer languages, namely C#, Java, VB. The first group (ie. Javascript, PHP, PERL, Ruby or Python) uses largely the same type of declaration for several dimensions. The Javascript example shows how to declare two-dimensional and three-dimensional array variables, where the pattern can be followed for any higher dimensions (ie. 4D, 5D, 6D, and so on). In PHP, PERL, Ruby or Python, the exemplification is only repeated for two dimensions and it assumes that for more than two dimensions the declarations can be made in the same way as in Javascript. The second group is more different, where Java, C# and VB are radically different in the way statements are made. Obviously, Java and C# have common syntax elements, but they differ a little in the way the declarations for arrays are made. In VB, the number of dimensions and the number of elements in each dimension are initially declared. Only then these elements in their respective dimensions can receive values by assignment. VB is so radically different when compared to other computer languages, that array variables have a lower bound (read through the LBound function) and an upper bound (read through the UBound function), a property that can open paths in prototyping (especially in science). In the VB examples, each Debug.Print statement line corresponds to a row in the output. Note that the source code is in context and works with copy/paste.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    int B[][2][3] = {
+                    {{1,2,3}, 
+                     {4,5,6}},
+                    {{7,8,9}, 
+                     {10,11,12}}
+                    };
+
+    cout<<"\n"<<B[0][1][1];
+    
+    return 0;
+}

Additional algorithm 19c.cpp

@@ -0,0 +1,22 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 19. It shows the way in which multidimensional array variables can be declared. An interesting difference can be observed between two groups of computer languages. A group involving Javascript, PHP, PERL, Ruby or Python and another group involving classic computer languages, namely C#, Java, VB. The first group (ie. Javascript, PHP, PERL, Ruby or Python) uses largely the same type of declaration for several dimensions. The Javascript example shows how to declare two-dimensional and three-dimensional array variables, where the pattern can be followed for any higher dimensions (ie. 4D, 5D, 6D, and so on). In PHP, PERL, Ruby or Python, the exemplification is only repeated for two dimensions and it assumes that for more than two dimensions the declarations can be made in the same way as in Javascript. The second group is more different, where Java, C# and VB are radically different in the way statements are made. Obviously, Java and C# have common syntax elements, but they differ a little in the way the declarations for arrays are made. In VB, the number of dimensions and the number of elements in each dimension are initially declared. Only then these elements in their respective dimensions can receive values by assignment. VB is so radically different when compared to other computer languages, that array variables have a lower bound (read through the LBound function) and an upper bound (read through the UBound function), a property that can open paths in prototyping (especially in science). In the VB examples, each Debug.Print statement line corresponds to a row in the output. Note that the source code is in context and works with copy/paste.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    int C[2][3];
+    
+    C[0][0] = 5;
+    C[0][1] = 6;
+    C[0][2] = 5;
+    
+    C[1][0] = 5;
+    C[1][1] = 5;
+    C[1][2] = 5;
+
+    cout<<"\n"<<C[0][1];
+    
+    return 0;
+}

Additional algorithm 2.cpp

@@ -0,0 +1,19 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 2. Examples of assignments are shown for multiple computer languages. An important observation is that VB refers to Visual Basic 6.0 (VB6) and VBA syntax, namely the last version of Visual Basic. Thus VB6 lacks aggregate assignment as this style is a relatively new addition to computer languages. VB6 can explicitly declare multiple variables for a certain data type (Dim a, b, c As Integer), however, it lacks the posibility for multiple assignment. Note that the source code is out of context and is intended for explanation of the method.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    int a, b, c;
+    
+    a = 1;	
+    
+    a += 1;	
+    
+    a = b = c = 1;
+    
+    cout<<(a + b + c);
+    return 0;
+}

Additional algorithm 2.py

@@ -0,0 +1,8 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 2. Examples of assignments are shown for multiple computer languages. An important observation is that VB refers to Visual Basic 6.0 (VB6) and VBA syntax, namely the last version of Visual Basic. Thus VB6 lacks aggregate assignment as this style is a relatively new addition to computer languages. VB6 can explicitly declare multiple variables for a certain data type (Dim a, b, c As Integer), however, it lacks the posibility for multiple assignment. Note that the source code is out of context and is intended for explanation of the method.
+
+a = 1	
+a += 1	
+a = b = c = 1
+
+print (a + b + c)

Additional algorithm 20.cpp

@@ -0,0 +1,18 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 20. Demonstrates the implementation of conditional statements. Three variables a, b and c are declared and assigned to different values. A condition triggers a statement to increment the value of variable c, only if the value of variable a is less than the value of variable b, otherwise a decrement is applied to the value of c. Note that the source code is in context and works with copy/paste.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    int a = 1;
+    int b = 2;
+    int c = 3;
+
+    if(a < b){c += 1;} else {c -= 1;}
+
+    cout<<"c="<<c;
+
+    return 0;
+}

Additional algorithm 20.py

@@ -0,0 +1,11 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 20. Demonstrates the implementation of conditional statements. Three variables a, b and c are declared and assigned to different values. A condition triggers a statement to increment the value of variable c, only if the value of variable a is less than the value of variable b, otherwise a decrement is applied to the value of c. Note that the source code is in context and works with copy/paste.
+
+a = 1
+b = 2
+c = 3
+
+if a < b: c += 1 
+else: c -= 1
+
+print ("c=" + str(c))

Additional algorithm 21.cpp

@@ -0,0 +1,16 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 21. Demonstrates the implementation of conditional statements on array variables. Three elements of an array variable (A) are declared and filled with values. A condition triggers a statment to increment the value of the last element of the array (ie. A[2]), only if the value of the first element (ie. A[0]) is less than the value of the second element (ie. A[1]), otherwise a decrement is applied to the value of the last element of the array. Note that the source code is in context and works with copy/paste.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    int A[] = {1, 2, 3};
+
+    if(A[0] < A[1]){A[2] += 1;}
+
+    cout<<"A[2]="<<A[2];
+
+    return 0;
+}

Additional algorithm 21.py

@@ -0,0 +1,8 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 21. Demonstrates the implementation of conditional statements on array variables. Three elements of an array variable (A) are declared and filled with values. A condition triggers a statment to increment the value of the last element of the array (ie. A[2]), only if the value of the first element (ie. A[0]) is less than the value of the second element (ie. A[1]), otherwise a decrement is applied to the value of the last element of the array. Note that the source code is in context and works with copy/paste.
+
+A = [1, 2, 3];
+
+if A[0] < A[1]: A[2] += 1
+
+print ("A[2]=" + str(A[2]))

Additional algorithm 22.py

@@ -0,0 +1,8 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 22. Here the positive increment while-loop structure is demonstrated. A variable i is declared and set to zero. A while loop structure increments variable i from its initial value to its upper limit (number five). At each iteration, variable i is printed in the output. The result is an enumeration of values from 0 to 4. Note that the source code is in context and works with copy/paste.
+
+i = 0
+
+while i < 5:
+  print('i = ' + str(i))
+  i += 1

Additional algorithm 22a.cpp

@@ -0,0 +1,17 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 22. Here the positive increment while-loop structure is demonstrated. A variable i is declared and set to zero. A while loop structure increments variable i from its initial value to its upper limit (number five). At each iteration, variable i is printed in the output. The result is an enumeration of values from 0 to 4. Note that the source code is in context and works with copy/paste.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    int i = 0;
+
+    while (i < 5) {
+        cout<<"\n i = "<<i;
+        i++;
+    }
+
+    return 0;
+}

Additional algorithm 22b.cpp

@@ -0,0 +1,18 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 22. Here the positive increment while-loop structure is demonstrated. A variable i is declared and set to zero. A while loop structure increments variable i from its initial value to its upper limit (number five). At each iteration, variable i is printed in the output. The result is an enumeration of values from 0 to 4. Note that the source code is in context and works with copy/paste.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    int i = 0;
+
+    do {
+        cout<<"\n i = "<<i;
+        i++;
+    }
+    while (i < 5);
+
+    return 0;
+}

Additional algorithm 23.py

@@ -0,0 +1,13 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 23. It demonstrates the traversal of a one-dimensional array. An array variable is declared with string literals. The implementation also uses two other variables. A variable t stores string values and is initially set to empty. Another variable (ie. i) initialized with value zero is the counter of a while-loop. The while-loop traverses the elements of array A by using the counter i as an index. At each iteration, the value from an element is added together with other string characters to the variable t. Once the end of the while-loop cycle is reached, the value collected in the variable t is printed in the output for inspection. Note that the source code is in context and works with copy/paste.
+
+A = ["a", "b", "c", "d", "e", "f", "g"]
+
+i = 0
+t = ''
+
+while i <= len(A)-1:
+  t += "\n i[" + str(i) + "]=" + str(A[i])
+  i += 1
+  
+print(t)

Additional algorithm 23a.cpp

@@ -0,0 +1,23 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 23. It demonstrates the traversal of a one-dimensional array. An array variable is declared with string literals. The implementation also uses two other variables. A variable t stores string values and is initially set to empty. Another variable (ie. i) initialized with value zero is the counter of a while-loop. The while-loop traverses the elements of array A by using the counter i as an index. At each iteration, the value from an element is added together with other string characters to the variable t. Once the end of the while-loop cycle is reached, the value collected in the variable t is printed in the output for inspection. Note that the source code is in context and works with copy/paste.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    string A[] = {"a", "b", "c", "d", "e"};
+    int n = sizeof(A) / sizeof A[0];
+
+    int i = 0;
+    string t = "";
+
+    while (i < n) {
+        t += "\n i[" + to_string(i);
+        t += "]=" + A[i];
+        i++;
+    }
+
+    cout<<t;
+    return 0;
+}

Additional algorithm 23b.cpp

@@ -0,0 +1,24 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 23. It demonstrates the traversal of a one-dimensional array. An array variable is declared with string literals. The implementation also uses two other variables. A variable t stores string values and is initially set to empty. Another variable (ie. i) initialized with value zero is the counter of a while-loop. The while-loop traverses the elements of array A by using the counter i as an index. At each iteration, the value from an element is added together with other string characters to the variable t. Once the end of the while-loop cycle is reached, the value collected in the variable t is printed in the output for inspection. Note that the source code is in context and works with copy/paste.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    string A[] = {"a", "b", "c", "d", "e"};
+    int n = sizeof(A) / sizeof A[0];
+
+    int i = 0;
+    string t = "";
+
+    do {
+        t += "\n i[" + to_string(i);
+        t += "]=" + A[i];
+        i++;
+    }
+    while (i < n);
+
+    cout<<t;
+    return 0;
+}

Additional algorithm 24.cpp

@@ -0,0 +1,18 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 24. The for-loop cycle for incrementing some simple variables is demonstrated. Specifically, two variables a and b are declared and initialized. The variable a is initialized to the integer five and the variable b is set to zero. The for-loop is then declared to start at the initial value of i and end at the value indicated by variable a. At each increment, the value in variable i is added to the numeric value stored in variable b. At the end of the loop, the final value stored in variable b is printed to the output for inspection. Note that the source code is in context and works with copy/paste.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    int a = 5;
+    int b = 0;
+    
+    for (int i = 0; i < a; i++) {
+        b += i;
+    }
+
+    cout<<b;
+    return 0;
+}

Additional algorithm 24.py

@@ -0,0 +1,10 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 24. The for-loop cycle for incrementing some simple variables is demonstrated. Specifically, two variables a and b are declared and initialized. The variable a is initialized to the integer five and the variable b is set to zero. The for-loop is then declared to start at the initial value of i and end at the value indicated by variable a. At each increment, the value in variable i is added to the numeric value stored in variable b. At the end of the loop, the final value stored in variable b is printed to the output for inspection. Note that the source code is in context and works with copy/paste.
+
+a = 5
+b = 0
+
+for i in range(0, a):
+   b += i
+
+print (b)

Additional algorithm 25.cpp

@@ -0,0 +1,23 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 25. It demonstrates the use of a for-loop for the traversal of a one-dimensional array. An array variable is declared with string literals. The implementation also uses two other variables. A variable t stores string values and is initially set to empty. Another variable (ie. i) initialized with value zero is the counter of a for-loop. The for-loop traverses the elements of array A by using the counter i as an index. At each iteration, the value from an element is added together with other string characters to the content of variable t. Once the end of the for-loop cycle is reached, the value collected in variable t is printed in the output for inspection. Note that the source code is in context and works with copy/paste.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    string A[] = {"a","b","c","d","e"};
+    string t = "";
+    
+    int n = sizeof(A) / sizeof A[0];
+
+    for (int i = 0; i < n; i++) {
+            
+        t += "A["+to_string(i)+"]=";
+        t += A[i]+"\n";
+    }
+    
+    cout<<t;
+
+    return 0;
+}

Additional algorithm 25.py

@@ -0,0 +1,12 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 25. It demonstrates the use of a for-loop for the traversal of a one-dimensional array. An array variable is declared with string literals. The implementation also uses two other variables. A variable t stores string values and is initially set to empty. Another variable (ie. i) initialized with value zero is the counter of a for-loop. The for-loop traverses the elements of array A by using the counter i as an index. At each iteration, the value from an element is added together with other string characters to the content of variable t. Once the end of the for-loop cycle is reached, the value collected in variable t is printed in the output for inspection. Note that the source code is in context and works with copy/paste.
+
+A = ["a", "b", "c", "d", "e"]
+
+i = 0
+t = ''
+
+for i in range(0, len(A)):
+    t += "\n A[" + str(i) + "]=" + str(A[i])
+
+print (t)

Additional algorithm 26.cpp

@@ -0,0 +1,31 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 26. It demonstrates the use of nested for-loops. It shows the traversal of a two-dimensional array by a nested for-loop structure. A 2D-array variable (A) is declared with mixed datatypes, namely with string literals and number literals. A string variable t is initially set to empty. Another two variables (ie. i and j) are initialized with value zero and are the main counters of nested for-loops. The upper limit of each for-loop is established by the two dimensions, namely the number of rows and columns from matrix A. The two for-loops traverse the elements of array A by using the counters i and j as an index. At each iteration, the value from an element is added to the content of variable t. Once the end of the nested for-loops is reached, the value collected in variable t is printed in the output for inspection. The end result is the enumeration of each value in the output, in a linear manner. Note that the source code is in context and works with copy/paste.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    string A[][2] = {
+                    {"a","b"},
+                    {"c","d"},
+                    {"e","f"},
+                    {"g","h"},
+                    };
+    string t = "";
+    
+    int n =  sizeof(A) / sizeof A[0];
+    int m = sizeof A[0] / sizeof(string);
+
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < m; j++) {
+            
+            t += "A["+to_string(i);
+            t += "]["+to_string(j);
+            t += "]="+A[i][j]+"\n";
+        }
+    }
+    cout<<t;
+
+    return 0;
+}

Additional algorithm 26.py

@@ -0,0 +1,16 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 26. It demonstrates the use of nested for-loops. It shows the traversal of a two-dimensional array by a nested for-loop structure. A 2D-array variable (A) is declared with mixed datatypes, namely with string literals and number literals. A string variable t is initially set to empty. Another two variables (ie. i and j) are initialized with value zero and are the main counters of nested for-loops. The upper limit of each for-loop is established by the two dimensions, namely the number of rows and columns from matrix A. The two for-loops traverse the elements of array A by using the counters i and j as an index. At each iteration, the value from an element is added to the content of variable t. Once the end of the nested for-loops is reached, the value collected in variable t is printed in the output for inspection. The end result is the enumeration of each value in the output, in a linear manner. Note that the source code is in context and works with copy/paste.
+
+A = [["a", 88, 146],
+     ["b", 34, 124],
+     ["c", 96, 564],
+     [100, 12, "d"]]
+
+t = ""
+
+for i in range(0, len(A)):
+    for j in range(0, len(A[i])):
+        t += "\n A[" + str(i) + "]["
+        t += str(j) + "]=" + str(A[i][j])
+
+print(t)

Additional algorithm 27.cpp

@@ -0,0 +1,36 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 27. It demonstrates the use of a single for-loop for two-dimensional arrays. It shows the traversal of a two-dimensional array by one for-loop structure. A 2D-array variable (A) is declared with mixed datatypes as before, namely with string literals and number literals. A string variable t is initially set to empty. A variable v is set to zero and it represents the main counter of the for-loop. Another two variables (ie. i and j) are initialized with value zero and are the main coordinates for element identification. Each dimension of array A is stored in variables n and m, namely the number of rows in n and the number of columns in m. The upper limit of the for-loop is calculated based on the two known dimensions n and m. Thus, m times n establishes the upper limit of the for-loop. Here, the value of the counter v from the for-loop is used to calculate the i and j values that are used as an index to traverse the array variable A. The value of variable j is computed as the v % m and the result of this expression indicates the reminder (ex. 5 mod 3 is 2). The secret to this implementation is a condition that increments a variable i (rows) each time j (columns) equals zero. Thus, in this manner this approach provides the i and j values that a nested for-loop provides. At each iteration, the value from an element is added to the content of variable t. Once the end of the for-loop is reached, the value collected in variable t is printed in the output for inspection. The end result is the enumeration of each value in the output, in a linear manner. Note that the source code is in context and works with copy/paste.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    string A[][2] = {
+                    {"a","b"},
+                    {"c","d"},
+                    {"e","f"},
+                    {"g","h"},
+                    };
+    string t = "";
+    
+    int n =  sizeof(A) / sizeof A[0];
+    int m = sizeof A[0] / sizeof(string);
+
+    int i = 0;
+    int j = 0;
+
+    for (int v = 0; v < n*m; v++) {
+        
+        j = v % m;
+        if(v!=0 && j == 0){i++;}
+        
+        t += to_string(v);
+        t += " A["+to_string(i)+"][";
+        t += to_string(j)+"]=";
+        t += A[i][j] + "\n";
+    }
+    cout<<t;
+
+    return 0;
+}

Additional algorithm 27.py

@@ -0,0 +1,23 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 27. It demonstrates the use of a single for-loop for two-dimensional arrays. It shows the traversal of a two-dimensional array by one for-loop structure. A 2D-array variable (A) is declared with mixed datatypes as before, namely with string literals and number literals. A string variable t is initially set to empty. A variable v is set to zero and it represents the main counter of the for-loop. Another two variables (ie. i and j) are initialized with value zero and are the main coordinates for element identification. Each dimension of array A is stored in variables n and m, namely the number of rows in n and the number of columns in m. The upper limit of the for-loop is calculated based on the two known dimensions n and m. Thus, m times n establishes the upper limit of the for-loop. Here, the value of the counter v from the for-loop is used to calculate the i and j values that are used as an index to traverse the array variable A. The value of variable j is computed as the v % m and the result of this expression indicates the reminder (ex. 5 mod 3 is 2). The secret to this implementation is a condition that increments a variable i (rows) each time j (columns) equals zero. Thus, in this manner this approach provides the i and j values that a nested for-loop provides. At each iteration, the value from an element is added to the content of variable t. Once the end of the for-loop is reached, the value collected in variable t is printed in the output for inspection. The end result is the enumeration of each value in the output, in a linear manner. Note that the source code is in context and works with copy/paste.
+
+A = [["a", 88, 146],
+     ["b", 34, 124],
+     ["c", 96, 564],
+     [100, 12, "d"]]
+
+t = ""
+n = len(A)     # rows
+m = len(A[0])  # columns
+
+i = 0
+j = 0
+
+for v in range(0, n*m):
+    j = v % m
+    if(v != 0 and j == 0):
+        i = i + 1
+    t += str(v) + " A[" + str(i) + "]["
+    t += str(j) + "]=" + str(A[i][j]) + "\n"
+
+print(t)

Additional algorithm 28.cpp

@@ -0,0 +1,4 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 28. It demonstrates the use of a single for-loop for three-dimensional arrays, with an extrapolation to multidimensional arrays. Note that the example shown here is done only for Javascript in order to preserve paper. One can port this in any other language as previously shown. The traversal of a 3D array using only one for-loop structure, is based on the previous example. A 3D-array variable (A) is declared with mixed datatypes, namely with string literals and number literals. The 3D-array is represented by five matrices, in which the columns represent one dimension, the rows represent the second dimension, and the number of matrices, represents the third dimension. Thus, this array can be understood as a cube-like structure. A string variable t is initially set to empty. A variable v is set to zero and it represents the main counter of the for-loop. Another three variables (ie. i, j and d) are initialized with a value of zero and are the main coordinates for array element identification. Each dimension of array A is stored in variables s, m and n, namely the number of matrices in s, the number of rows in m and the number of columns in n. The upper limit of the for-loop is calculated as s × m × n. Here, the value of the counter v from the for-loop is used, as before, to calculate the i, j and d values that are used as an index to traverse the array variable A. The value of variable j is computed as the v % m. A condition increments a variable i (rows) each time j (columns) equals zero. Thus, both i and j values are computed. However, the value for variable d (matrix number) is calculated as v % (m×n), which provides a value of zero each time a matrix was traversed. Thus, a condition increments variable d and resets variable i, each time the value of k equals zero. At each iteration, the value from an element (d, i, j) is added to the content of variable t. Once the end of the for-loop is reached, the string value collected in variable t is printed in the output for inspection. The end result is the enumeration of each value in the output, in a linear manner. Note that the source code is in context and works with copy/paste.
+
+// this example was provided only in Javascript

Additional algorithm 28.py

@@ -0,0 +1,4 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 28. It demonstrates the use of a single for-loop for three-dimensional arrays, with an extrapolation to multidimensional arrays. Note that the example shown here is done only for Javascript in order to preserve paper. One can port this in any other language as previously shown. The traversal of a 3D array using only one for-loop structure, is based on the previous example. A 3D-array variable (A) is declared with mixed datatypes, namely with string literals and number literals. The 3D-array is represented by five matrices, in which the columns represent one dimension, the rows represent the second dimension, and the number of matrices, represents the third dimension. Thus, this array can be understood as a cube-like structure. A string variable t is initially set to empty. A variable v is set to zero and it represents the main counter of the for-loop. Another three variables (ie. i, j and d) are initialized with a value of zero and are the main coordinates for array element identification. Each dimension of array A is stored in variables s, m and n, namely the number of matrices in s, the number of rows in m and the number of columns in n. The upper limit of the for-loop is calculated as s × m × n. Here, the value of the counter v from the for-loop is used, as before, to calculate the i, j and d values that are used as an index to traverse the array variable A. The value of variable j is computed as the v % m. A condition increments a variable i (rows) each time j (columns) equals zero. Thus, both i and j values are computed. However, the value for variable d (matrix number) is calculated as v % (m×n), which provides a value of zero each time a matrix was traversed. Thus, a condition increments variable d and resets variable i, each time the value of k equals zero. At each iteration, the value from an element (d, i, j) is added to the content of variable t. Once the end of the for-loop is reached, the string value collected in variable t is printed in the output for inspection. The end result is the enumeration of each value in the output, in a linear manner. Note that the source code is in context and works with copy/paste.
+
+# this example was provided only in Javascript

Additional algorithm 29.cpp

@@ -0,0 +1,17 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 29. It shows the use of functions that take simple arguments. An integer literal is assigned to a variable a. Variable a is then used as an argument for a function called "compute". Function "compute" takes the argument and uses its value in a mathematical expression. The returned value of function "compute" is then assigned to a variable b, which is then printed into the output for inspection. Note that the source code is in context and works with copy/paste.
+
+int compute(int x)
+{
+    return x + x / x - x * x;
+}
+
+int main()
+{
+    int a = 10;
+    int b = compute(a); 
+    
+    cout<<b;
+
+    return 0;
+}

Additional algorithm 29.py

@@ -0,0 +1,9 @@
+#Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+#Additional algorithm 29. It shows the use of functions that take simple arguments. An integer literal is assigned to a variable a. Variable a is then used as an argument for a function called "compute". Function "compute" takes the argument and uses its value in a mathematical expression. The returned value of function "compute" is then assigned to a variable b, which is then printed into the output for inspection. Note that the source code is in context and works with copy/paste.
+
+def compute(x):
+    return x + x / x - x * x
+    
+a = 10
+b = compute(a)
+print(b)

Additional algorithm 3.cpp

@@ -0,0 +1,13 @@
+//Paul A. Gagniuc. An Introduction to Programming Languages: Simultaneous Learning in Multiple Coding Environments. Synthesis Lectures on Computer Science. Springer International Publishing, 2023, pp. 1-280.
+//Additional algorithm 3. The first line of each computer language in the above list, shows an extraction of an ASCII character on the basis of an ASCII code. The second line shows the extraction of the ASCII code based on a given ASCII character. The output for any of the above statements is "Code 65 is the:'A' letter" and "Letter A has the code:'65'". Note that the source code is in context and works with copy/paste.
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    cout<<"Code 65 is the:'"<<(char) 65<<"' letter\n";
+    cout<<"Letter A has the code:'"<<(int) 'A'<<"'";
+
+    return 0;
+}