del semicolon sign

iamlorddop · iamlorddop · commit 529f4be8258a · 2023-03-03T18:15:22.000+03:00
diff --git a/bubble-sort/javascript/bubble-sort.js b/bubble-sort/javascript/bubble-sort.js
@@ -1,23 +1,23 @@
-let firstArray = [];
-let secondArray = [1, 1, 19, 4, 5];
-let thirdArray = [-1, 2, 4, -5, 10];
-let fourthArray = [-1, -5, -12, -2, 0];
+let firstArray = []
+let secondArray = [1, 1, 19, 4, 5]
+let thirdArray = [-1, 2, 4, -5, 10]
+let fourthArray = [-1, -5, -12, -2, 0]
 
 // Generate an array with random numbers
 for(let i = 0; i < 5; i++) {
-	firstArray.push(Math.round(Math.random() * 100));
+	firstArray.push(Math.round(Math.random() * 100))
 }
 
-console.log(`Before sort 1 array: ${firstArray}\nBefore sort 2 array: ${secondArray}\nBefore sort 3 array: ${thirdArray}\nBefore sort 4 array: ${fourthArray}`);
+console.log(`Before sort 1 array: ${firstArray}\nBefore sort 2 array: ${secondArray}\nBefore sort 3 array: ${thirdArray}\nBefore sort 4 array: ${fourthArray}`)
 
 // First concept
 function bubbleSort (arr) {
 	for(let i = arr.length - 1; i > 0; i--) {
 		for (let j = 0; j < i; j++) {
 			if(arr[j] > arr[j + 1]) {
-				let temp = arr[j];
-				arr[j] = arr[j + 1];
-				arr[j + 1] = temp;
+				let temp = arr[j]
+				arr[j] = arr[j + 1]
+				arr[j + 1] = temp
 			}
 		}
 	}
@@ -26,30 +26,30 @@ function bubbleSort (arr) {
 // Second concept
 function bubbleSortSecondConcept (arr) {
 	do {
-		swapped = false;
-		console.log(arr);
+		swapped = false
+		console.log(arr)
 		arr.forEach((item, index) => {
 		  if (item > arr[index + 1]) {
 			 // Save the value to a variable so we don't lose it
-			 let temp = item;
-			 arr[index] = arr[index + 1];
-			 arr[index + 1] = temp;
-			 swapped = true;
+			 let temp = item
+			 arr[index] = arr[index + 1]
+			 arr[index + 1] = temp
+			 swapped = true
 		  }
 		})
-	} while (swapped);
+	} while (swapped)
 }
 
 // Test for first concept
-bubbleSort(firstArray);
-bubbleSort(secondArray);
-bubbleSort(thirdArray);
-bubbleSort(fourthArray);
+bubbleSort(firstArray)
+bubbleSort(secondArray)
+bubbleSort(thirdArray)
+bubbleSort(fourthArray)
 
 // Test for first concept
-bubbleSortSecondConcept(firstArray);
-bubbleSortSecondConcept(secondArray);
-bubbleSortSecondConcept(thirdArray);
-bubbleSortSecondConcept(fourthArray);
+bubbleSortSecondConcept(firstArray)
+bubbleSortSecondConcept(secondArray)
+bubbleSortSecondConcept(thirdArray)
+bubbleSortSecondConcept(fourthArray)
 
-console.log(`After sort 1 array: ${firstArray}\nAfter sort 2 array: ${secondArray}\nAfter sort 3 array: ${thirdArray}\nAfter sort 4 array: ${fourthArray}`);
+console.log(`After sort 1 array: ${firstArray}\nAfter sort 2 array: ${secondArray}\nAfter sort 3 array: ${thirdArray}\nAfter sort 4 array: ${fourthArray}`)
diff --git a/insertion-sort/javascript/insertion-sort.js b/insertion-sort/javascript/insertion-sort.js
@@ -1,78 +1,78 @@
-let firstArray = [];
-let secondArray = [1, 1, 19, 4, 5];
-let thirdArray = [-1, 2, 4, -5, 10];
-let fourthArray = [-1, -5, -12, -2, 0];
-let fifthArray =[ 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54];
+let firstArray = []
+let secondArray = [1, 1, 19, 4, 5]
+let thirdArray = [-1, 2, 4, -5, 10]
+let fourthArray = [-1, -5, -12, -2, 0]
+let fifthArray =[ 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54]
 
 // Generate an array with random numbers
 for(let i = 0; i < 5; i++) {
-	firstArray.push(Math.round(Math.random() * 100));
+	firstArray.push(Math.round(Math.random() * 100))
 }
 
-console.log(`Before sort 1 array: ${firstArray}\nBefore sort 2 array: ${secondArray}\nBefore sort 3 array: ${thirdArray}\nBefore sort 4 array: ${fourthArray}\nBefore binary sort 5 array: ${fifthArray}`);
+console.log(`Before sort 1 array: ${firstArray}\nBefore sort 2 array: ${secondArray}\nBefore sort 3 array: ${thirdArray}\nBefore sort 4 array: ${fourthArray}\nBefore binary sort 5 array: ${fifthArray}`)
 
 function insertionSort(arr) { 
-   let key, j; 
+   let key, j
    for (let i = 1; i < arr.length; i++) { 
-      key = arr[i]; 
-      j = i - 1; 
+      key = arr[i]
+      j = i - 1
       /* Move elements of arr[0..i-1], that are 
       greater than key, to one position ahead 
       of their current position */
       while (j >= 0 && arr[j] > key) { 
-         arr[j + 1] = arr[j]; 
-         j = j - 1; 
+         arr[j + 1] = arr[j] 
+         j = j - 1
       } 
-      arr[j + 1] = key; 
+      arr[j + 1] = key 
    } 
-	return arr;
+	return arr
 } 
 
 // binary insertion sort
 function binarySearch(a, item, low, high) {
    if (high <= low)
-      return (item > a[low]) ? (low + 1) : low;
+      return (item > a[low]) ? (low + 1) : low
   
-   mid = Math.floor((low + high) / 2);
+   mid = Math.floor((low + high) / 2)
   
    if(item == a[mid])
-      return mid + 1;
+      return mid + 1
   
    if(item > a[mid])
-      return binarySearch(a, item, mid + 1, high);
+      return binarySearch(a, item, mid + 1, high)
           
-   return binarySearch(a, item, low, mid - 1);
+   return binarySearch(a, item, low, mid - 1)
 }
  
 function binaryInsertionSort(arr) {
    for (let i = 1; i < arr.length; i++) {
-      let j = i - 1;
-      let x = arr[i];
+      let j = i - 1
+      let x = arr[i]
   
       // Find location to insert
       // using binary search
-      let loc = Math.abs(binarySearch(arr, x, 0, j));
+      let loc = Math.abs(binarySearch(arr, x, 0, j))
   
       // Shifting array to one
       // location right
              
       while (j >= loc) {
-         arr[j + 1] = arr[j];
-         j--;
+         arr[j + 1] = arr[j]
+         j--
       }
   
       // Placing element at its
       // correct location
-      arr[j+1] = x;
+      arr[j+1] = x
    }
 }
 
 // Test
-insertionSort(firstArray);
-insertionSort(secondArray);
-insertionSort(thirdArray);
-insertionSort(fourthArray);
+insertionSort(firstArray)
+insertionSort(secondArray)
+insertionSort(thirdArray)
+insertionSort(fourthArray)
 
 binaryInsertionSort(fifthArray)
 
-console.log(`After sort 1 array: ${firstArray}\nAfter sort 2 array: ${secondArray}\nAfter sort 3 array: ${thirdArray}\nAfter sort 4 array: ${fourthArray}\nAfter binary sort 5 array: ${fifthArray}`);
+console.log(`After sort 1 array: ${firstArray}\nAfter sort 2 array: ${secondArray}\nAfter sort 3 array: ${thirdArray}\nAfter sort 4 array: ${fourthArray}\nAfter binary sort 5 array: ${fifthArray}`)
diff --git a/quick-sort/javascript/quick-sort.js b/quick-sort/javascript/quick-sort.js
@@ -1,55 +1,55 @@
-let firstArray = [];
-let secondArray = [1, 1, 19, 4, 5];
-let thirdArray = [-1, 2, 4, -5, 10];
-let fourthArray = [-1, -5, -12, -2, 0];
+let firstArray = []
+let secondArray = [1, 1, 19, 4, 5]
+let thirdArray = [-1, 2, 4, -5, 10]
+let fourthArray = [-1, -5, -12, -2, 0]
 
 // Generate an array with random numbers
 for(let i = 0; i < 5; i++) {
-	firstArray.push(Math.round(Math.random() * 100));
+	firstArray.push(Math.round(Math.random() * 100))
 }
 
-console.log(`Before sort 1 array: ${firstArray}\nBefore sort 2 array: ${secondArray}\nBefore sort 3 array: ${thirdArray}\nBefore sort 4 array: ${fourthArray}`);
+console.log(`Before sort 1 array: ${firstArray}\nBefore sort 2 array: ${secondArray}\nBefore sort 3 array: ${thirdArray}\nBefore sort 4 array: ${fourthArray}`)
 
 // First concept
 function firstQuickSort(arr) {
-	if (arr.length < 2) return arr;
-	let pivot = arr[0];
-	const left = [];
-	const right = [];
+	if (arr.length < 2) return arr
+	let pivot = arr[0]
+	const left = []
+	const right = []
 	  
 	for (let i = 1; i < arr.length; i++) {
 	  	if (pivot > arr[i]) {
-		 	left.push(arr[i]);
+		 	left.push(arr[i])
 	  	} else {
-		 	right.push(arr[i]);
+		 	right.push(arr[i])
 	  	}
 	}
-	return firstQuickSort(left).concat(pivot, firstQuickSort(right));
+	return firstQuickSort(left).concat(pivot, firstQuickSort(right))
 }
 
 // Second concept
 function secondQuickSort(arr) {
-	if (arr.length < 2) return arr;
-	let min = 1;
-	let max = arr.length - 1;
-	let rand = Math.floor(min + Math.random() * (max + 1 - min));
-	let pivot = arr[rand];
-	const left = [];
-	const right = [];
-	arr.splice(arr.indexOf(pivot), 1);
-	arr = [pivot].concat(arr);
+	if (arr.length < 2) return arr
+	let min = 1
+	let max = arr.length - 1
+	let rand = Math.floor(min + Math.random() * (max + 1 - min))
+	let pivot = arr[rand]
+	const left = []
+	const right = []
+	arr.splice(arr.indexOf(pivot), 1)
+	arr = [pivot].concat(arr)
 	for (let i = 1; i < arr.length; i++) {
 	  	if (pivot > arr[i]) {
-		 	left.push(arr[i]);
+		 	left.push(arr[i])
 	  	} else {
-		 	right.push(arr[i]);
+		 	right.push(arr[i])
 	  	}
 	}
-	return secondQuickSort(left).concat(pivot, secondQuickSort(right));
+	return secondQuickSort(left).concat(pivot, secondQuickSort(right))
 }
 
 
 // Test
-console.log(`After first sort 1 array: ${firstQuickSort(firstArray)}\nAfter first sort 2 array: ${firstQuickSort(secondArray)}\nAfter first sort 3 array: ${firstQuickSort(thirdArray)}\nAfter first sort 4 array: ${firstQuickSort(fourthArray)}`);
+console.log(`After first sort 1 array: ${firstQuickSort(firstArray)}\nAfter first sort 2 array: ${firstQuickSort(secondArray)}\nAfter first sort 3 array: ${firstQuickSort(thirdArray)}\nAfter first sort 4 array: ${firstQuickSort(fourthArray)}`)
 
-console.log(`After second sort 1 array: ${secondQuickSort(firstArray)}\nAfter second sort 2 array: ${secondQuickSort(secondArray)}\nAfter second sort 3 array: ${secondQuickSort(thirdArray)}\nAfter second sort 4 array: ${secondQuickSort(fourthArray)}`);
+console.log(`After second sort 1 array: ${secondQuickSort(firstArray)}\nAfter second sort 2 array: ${secondQuickSort(secondArray)}\nAfter second sort 3 array: ${secondQuickSort(thirdArray)}\nAfter second sort 4 array: ${secondQuickSort(fourthArray)}`)
diff --git a/selection-sort/javascript/selection-sort.js b/selection-sort/javascript/selection-sort.js
@@ -1,31 +1,31 @@
-let firstArray = [];
-let secondArray = [1, 1, 19, 4, 5];
-let thirdArray = [-1, 2, 4, -5, 10];
-let fourthArray = [-1, -5, -12, -2, 0];
-let fifthArray = [4, 5, 3, 2, 4, 1];
+let firstArray = []
+let secondArray = [1, 1, 19, 4, 5]
+let thirdArray = [-1, 2, 4, -5, 10]
+let fourthArray = [-1, -5, -12, -2, 0]
+let fifthArray = [4, 5, 3, 2, 4, 1]
 
 // Generate an array with random numbers
 for(let i = 0; i < 5; i++) {
-	firstArray.push(Math.round(Math.random() * 100));
+	firstArray.push(Math.round(Math.random() * 100))
 }
 
-console.log(`Before sort 1 array: ${firstArray}\nBefore sort 2 array: ${secondArray}\nBefore sort 3 array: ${thirdArray}\nBefore sort 4 array: ${fourthArray}\nBefore stable sort 5 array: ${fifthArray}`);
+console.log(`Before sort 1 array: ${firstArray}\nBefore sort 2 array: ${secondArray}\nBefore sort 3 array: ${thirdArray}\nBefore sort 4 array: ${fourthArray}\nBefore stable sort 5 array: ${fifthArray}`)
 
 // Simple selection sort
 function selectionSort(arr) {
 	for(let i = 0; i < arr.length - 1; i++) {
-		let indexMin = i;
+		let indexMin = i
 
 		for(let j = i + 1; j < arr.length; j++) {
 			if(arr[indexMin] > arr[j]) {
-				indexMin = j;
+				indexMin = j
 			}
 		}
 		if(indexMin !== i) {
-			[arr[i], arr[indexMin]] = [arr[indexMin], arr[i]];
+			[arr[i], arr[indexMin]] = [arr[indexMin], arr[i]]
 		}
 	}
-	return arr;
+	return arr
 }
 
 // Stable selection sort
@@ -37,29 +37,29 @@ function stableSelectionSort(arr) {
    
       // Find minimum element from
       // arr[i] to arr[n - 1].
-      let min = i;
+      let min = i
       for (let j = i + 1; j < arr.length; j++) {
          if (arr[min] > arr[j]) {
-            min = j;
+            min = j
 			}
 		}
       // Move minimum element at current i.
-      let key = arr[min];
+      let key = arr[min]
       while (min > i) {
-         arr[min] = arr[min - 1];
-         min--;
+         arr[min] = arr[min - 1]
+         min--
       }
-      arr[i] = key;
+      arr[i] = key
    }
 }
 
 // Test for simple selection sort
-selectionSort(firstArray);
-selectionSort(secondArray);
-selectionSort(thirdArray);
-selectionSort(fourthArray);
+selectionSort(firstArray)
+selectionSort(secondArray)
+selectionSort(thirdArray)
+selectionSort(fourthArray)
 
 // Test for stable selection sort
-stableSelectionSort(fifthArray);
+stableSelectionSort(fifthArray)
 
-console.log(`After sort 1 array: ${firstArray}\nAfter sort 2 array: ${secondArray}\nAfter sort 3 array: ${thirdArray}\nAfter sort 4 array: ${fourthArray}\nAfter stable sort 5 array: ${fifthArray}`);
+console.log(`After sort 1 array: ${firstArray}\nAfter sort 2 array: ${secondArray}\nAfter sort 3 array: ${thirdArray}\nAfter sort 4 array: ${fourthArray}\nAfter stable sort 5 array: ${fifthArray}`)
