From 501db29d6158f8872b61286a647198a9f9ac16b1 Mon Sep 17 00:00:00 2001 From: MicahWoldu Date: Tue, 23 Aug 2016 21:00:32 +0100 Subject: [PATCH 1/3] Generating Sequences --- JavaScript/Generating-sequences.md | 68 ++++++++++++++++++++++++++++++ READMEs | 1 + 2 files changed, 69 insertions(+) create mode 100644 JavaScript/Generating-sequences.md create mode 160000 READMEs diff --git a/JavaScript/Generating-sequences.md b/JavaScript/Generating-sequences.md new file mode 100644 index 0000000..0be5709 --- /dev/null +++ b/JavaScript/Generating-sequences.md @@ -0,0 +1,68 @@ +# Generating-sequences + +Mathematical sequences occur so frequently in nature very often this transfers into computer programming problems. For example, the +cicadas who appear periodically but only emerge after a prime number of years. Or sunflowers which have either 34, 55 or 89 petals +on their face, depending upon the size of the sunflower. Additionally, lilies and irises have three petals, buttercups and wild roses +have five, delphiniums have eight petals, all related to the Fibonacci sequence. Or simply triangular numbers in bowling! +We are surrounded by sequences which are regularly analysed within computer programming. + +Being equipped to generate such sequences is vital. This is dedicated to exploring the possibleways these sequences can be produced +within a computer program using javascript: + +Prime Numbers + +A prime number is a natural number that has exactly two distinct natural number divisors: 1 and itself. There are several prime number +sieves in circulation, however, Sieve of Eratosthenes is a simple ancient algorithm. + +By iterating through an array of numbers starting at the beginning and removing all subsequent numbers that are a factor of the prime. +The multiples of a given prime are generated as a sequence of numbers starting from that prime, with constant difference between +them that is equal to that prime. This is the sieve's key distinction from using trial division to sequentially test each +candidate number for divisibility by each prime: + + function primes(num) { + var x = []; + for( var i =0; i<= num; i++) { + x[i] = true; + } + x[0]= false; + x[1]= false; + x[2]= true; + for ( var j = 2; j< num; j++) { + for (var k = 2; j*k <= num; k++) { + x[j*k] = false; + } + } + + primeValues = []; + + for (var i = 0; i< num; i ++) { + if (x[i] == true) { + primeValues.push(i); + } + } + return primeValues; + } + + primes(20); + [2, 3, 5, 7, 11, 13, 17, 19] + +Fibonnaci Sequence + +In mathematical terms, the sequence Fn of Fibonacci numbers is defined by the recurrence relation Fn = Fn-1 + Fn-2 with seed values. + + function fibonacci(nums) { + + var fibSequence = []; + + fibSequence[0] = 0; + fibSequence[1] = 1; + + for (var i = 2; i < nums; i ++) { + fibSequence[i] = fibSequence[i-1] + fibSequence[i-2]; + } + + return fibSequence; + } + + fibonacci(8); + [ 0, 1, 1, 2, 3, 5, 8, 13 ] \ No newline at end of file diff --git a/READMEs b/READMEs new file mode 160000 index 0000000..3057176 --- /dev/null +++ b/READMEs @@ -0,0 +1 @@ +Subproject commit 305717642304a62323f21c83045f898cf123fed5 From 2754347fc45e7d5f22ba57f170126d161e706a19 Mon Sep 17 00:00:00 2001 From: MicahWoldu Date: Wed, 24 Aug 2016 19:41:15 +0100 Subject: [PATCH 2/3] under the hood --- JavaScript/Closures.md | 6 +-- JavaScript/Generating-sequences.md | 2 +- JavaScript/array-map.md | 2 +- JavaScript/under-the-hood.md | 70 ++++++++++++++++++++++++++++++ 4 files changed, 75 insertions(+), 5 deletions(-) create mode 100644 JavaScript/under-the-hood.md diff --git a/JavaScript/Closures.md b/JavaScript/Closures.md index 4197413..68812ac 100644 --- a/JavaScript/Closures.md +++ b/JavaScript/Closures.md @@ -2,7 +2,7 @@ ### Introduction -Closures have a reputation for being one of JavaScript's most difficult concepts to grasp. However, if you're already comfortable with how JavaScript deals with functions and [scope][1], you're already halfway there. +Closures have a reputation for being one of JavaScript's most difficult concepts to grasp, however, if you're already comfortable with the way JavaScript deals with functions and [scope][1], you're already halfway there. ---- @@ -35,9 +35,9 @@ d; // 6 The variable `a` has **global scope** so can be accessed anywhere. -The variable `b` has **local scope**, local to the function `outer()` - it can only be accessed inside of it. Similarly, variable `c` is local to the function `inner()` and can only be accessed inside of it. +The variable `b` has **local scope** - local to the function `outer()` - it can only be accessed inside it. Similarly, variable `c` is local to the function `inner()` and can only be accessed inside it. -However, due to **lexical scope**, `inner()` also has access to variables `b` and `a` because they are defined within the its parent functions - `outer()` and the global space. +However, due to **lexical scope**, `inner()` also has access to variables `b` and `a` because they are defined within the parent function - `outer()`- and also the global space. Running this code, we set `a` and then call `outer()`, which sets `b` and calls `inner()`, which sets `c` and adds `a`, `b` and `c` together, returning a value of `6` because it has access to all 3 variables. Finally, the value of `6` is returned by `outer()` and assigned to `d`. diff --git a/JavaScript/Generating-sequences.md b/JavaScript/Generating-sequences.md index 0be5709..3a77abd 100644 --- a/JavaScript/Generating-sequences.md +++ b/JavaScript/Generating-sequences.md @@ -48,7 +48,7 @@ candidate number for divisibility by each prime: Fibonnaci Sequence -In mathematical terms, the sequence Fn of Fibonacci numbers is defined by the recurrence relation Fn = Fn-1 + Fn-2 with seed values. +In mathematical terms, the sequence Fn of Fibonacci numbers is defined by the recurrence relation Fn = Fn-1 + Fn-2 with seed values 0,1. function fibonacci(nums) { diff --git a/JavaScript/array-map.md b/JavaScript/array-map.md index 3c473f4..515bc39 100644 --- a/JavaScript/array-map.md +++ b/JavaScript/array-map.md @@ -1,7 +1,7 @@ # Array `map()` method -The `map()` method creates a new array, without altering the original, by applying a function to each element of the array. The transformation (or processing) is done by a callback function, which is specified as the first parameter of the method. Higher-order functions such as `map()`, `reduce()` or `filter()` are a shorter, more readable alternative to iterating through an array with a loop. +The `map()` method creates a new array, without altering the original, by applying a function to each element of the array. The transformation (or processing) is done by a callback function, which is specified as the first parameter of the method. Higher-order functions such as `map()`, `reduce()` or `filter()` are a shorter, more readable, alternative to iterating through an array with a loop. ## Example diff --git a/JavaScript/under-the-hood.md b/JavaScript/under-the-hood.md new file mode 100644 index 0000000..a818827 --- /dev/null +++ b/JavaScript/under-the-hood.md @@ -0,0 +1,70 @@ +# Under-the-Hood + + Fundamentally all characters are a higher level abstraction of a bit number. Subsequently every character has a corresponding number value. Many programming problems are made more accessible when viewed in this way. Furthermore, it also helps to lend understanding to built-in Javascript methods such as sort(); which is able to arrange characters of the same case in alphabetical order. + + Example of sort() being used: + + function arrange(values) { + values.sort(); + return values; + } + arrange(["China", "Germany", "United States", "Great Britain", Brazil"]); + + //[ 'Brazil', 'China', 'Germany', 'Great Britain', 'United States' ] + +In order to discover the unicode value of a particular character at a specified index in a string the charCodeAt() method is used: + + function findCharCode(string) { + var newArray = []; + for(var i = 0; i < string.length; i++) { + newArray.push(string.charCodeAt(i)); + } + return newArray; + } + findCharCode("GITHUB"); + + //[71, 73, 84, 72, 85, 66] + +In contrast, the fromCharCode() method converts Unicode values into characters. Note: This is a static method of the String object, +and the syntax is always String.fromCharCode(). + + function char(value) { + var result = ""; + for (var i = 0; i < value.length; i++) { + result += String.fromCharCode(value[i]); + } + return result; + } + char([97, 121, 108, 101, 114]); + + //'ayler' + +Unicode Characters: + + D.V Char D.V Char D.V Char D.V Char + 32 SPACE 56 8 80 P 104 h + 33 ! 57 9 81 Q 105 i + 34 " 58 : 82 R 106 j + 35 # 59 ; 83 S 107 k + 36 $ 60 < 84 T 108 l + 37 % 61 = 85 U 109 m + 38 & 62 > 86 V 110 n + 39 ' 63 ? 87 W 111 o + 40 ( 64 @ 88 X 112 p + 41 ) 65 A 89 Y 113 q + 42 * 66 B 90 Z 114 r + 43 + 67 C 91 [ 115 s + 44 , 68 D 92 \ 116 t + 45 - 69 E 93 ] 117 u + 46 . 70 F 94 ^ 118 v + 47 / 71 G 95 _ 119 w + 48 0 72 H 96 ` 120 x + 49 1 73 I 97 a 121 y + 50 2 74 J 98 b 122 z + 51 3 75 K 99 c + 52 4 76 L 100 d + 53 5 77 M 101 e + 54 6 78 N 102 f + 55 7 79 O 103 g + +Key: D.V = Decimal Value \ No newline at end of file From 50dc38e0a34dd6be3deba2d7dead31fb024267a1 Mon Sep 17 00:00:00 2001 From: MicahWoldu Date: Wed, 24 Aug 2016 23:00:54 +0100 Subject: [PATCH 3/3] Update Generating-sequences.md --- JavaScript/Generating-sequences.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/JavaScript/Generating-sequences.md b/JavaScript/Generating-sequences.md index 3a77abd..3f3c1c7 100644 --- a/JavaScript/Generating-sequences.md +++ b/JavaScript/Generating-sequences.md @@ -6,7 +6,7 @@ on their face, depending upon the size of the sunflower. Additionally, lilies an have five, delphiniums have eight petals, all related to the Fibonacci sequence. Or simply triangular numbers in bowling! We are surrounded by sequences which are regularly analysed within computer programming. -Being equipped to generate such sequences is vital. This is dedicated to exploring the possibleways these sequences can be produced +Being equipped to generate such sequences is vital. This article is dedicated to exploring the possible ways these sequences can be produced within a computer program using javascript: Prime Numbers @@ -65,4 +65,4 @@ In mathematical terms, the sequence Fn of Fibonacci numbers is defined by the re } fibonacci(8); - [ 0, 1, 1, 2, 3, 5, 8, 13 ] \ No newline at end of file + [ 0, 1, 1, 2, 3, 5, 8, 13 ]