- );
- }
+
+ );
}
export default App;
diff --git a/src/App.test.js b/src/App.test.js
new file mode 100644
index 0000000..1f03afe
--- /dev/null
+++ b/src/App.test.js
@@ -0,0 +1,8 @@
+import { render, screen } from '@testing-library/react';
+import App from './App';
+
+test('renders learn react link', () => {
+ render();
+ const linkElement = screen.getByText(/learn react/i);
+ expect(linkElement).toBeInTheDocument();
+});
diff --git a/src/Playground.js b/src/Playground.js
new file mode 100644
index 0000000..494eabf
--- /dev/null
+++ b/src/Playground.js
@@ -0,0 +1,70 @@
+class Rectangle {
+ constructor(height, width) {
+ this.height = height;
+ this.width = width;
+ }
+ get area() {
+ return this.calcArea();
+ }
+ calcArea() {
+ return this.height * this.width;
+ }
+}
+
+const rect1 = new Rectangle(30, 50);
+const rect2 = new Rectangle(40, 50);
+const rect3 = new Rectangle(10, 20);
+
+const tab = [rect1.area, rect2.area, rect3.area];
+const sortedtab = tab.sort(function (tab, temp) {
+ return tab - temp;
+});
+const prettytab = sortedtab.toString();
+
+let Sheet = { w: 10, h: 5 };
+const Square = { w: 4, h: 4 };
+
+let activities = [
+ ["Work", 9],
+ ["Eat", 1],
+ ["Commute", 2],
+ ["Play Game", 1],
+ ["Sleep", 7],
+];
+console.table(activities);
+// loop the outer array
+for (let i = 0; i < activities.length; i++) {
+ // get the size of the inner array
+ var innerArrayLength = activities[i].length;
+ // loop the inner array
+ for (let j = 0; j < innerArrayLength; j++) {
+ console.log("[" + i + "," + j + "] = " + activities[i][j]);
+ }
+}
+
+/*
+
+
+There are a few ways of doing this, so I'll just give an example of a simple to understand (if somewhat inefficient) method that should still give fairly decent results.
+
+ Start by ordering your boxes from largest to smallest.
+ Presume that your first box is going to be square (it won't end up that way, but it will end close). Take sqrt(area[1]) to get the length of its side. Take that width as the width you want for your first column.
+ Given that width, fill as many more rows as you can in that column.
+ Add up how much total area you have put in the column; resize its width to be match that (it will now be a little thinner).
+ Repeat steps 1-3 for the rest of the available boxes. When you get to the point where the target width for your first box in the column is wider than the amount of space you have left, just use that width.
+ The remaining boxes should cleanly fit into that remaining space in that column.
+
+This will give you aligned columns, with varying height divisions. As an alternative, you can flip "row" and "column" to get constant row divisions with varying column splits.
+
+
+*/
+
+export default function Playground(props) {
+ return (
+ <>
+
{props.title}
+
Here is where the magic will happen.
+
Soon enough.
+
+ );
+}
diff --git a/src/algorithms/bubbleSort.js b/src/algorithms/bubbleSort.js
deleted file mode 100644
index fd96a6b..0000000
--- a/src/algorithms/bubbleSort.js
+++ /dev/null
@@ -1,27 +0,0 @@
-import { swap } from "../helpers/helpers.js";
-
-const bubbleSort = (array, position, arraySteps, colorSteps) => {
- let colorKey = colorSteps[colorSteps.length - 1].slice();
-
- for (let i = 0; i < array.length - 1; i++) {
- for (let j = 0; j < array.length - i - 1; j++) {
- if (array[j] > array[j + 1]) {
- array = swap(array, j, j + 1);
- }
- arraySteps.push(array.slice());
- colorKey[j] = 1;
- colorKey[j + 1] = 1;
- colorSteps.push(colorKey.slice());
- colorKey[j] = 0;
- colorKey[j + 1] = 0;
- }
- colorKey[array.length - 1 - i] = 2;
- arraySteps.push(array.slice());
- colorSteps.push(colorKey.slice());
- }
-
- colorSteps[colorSteps.length - 1] = new Array(array.length).fill(2);
- return;
-};
-
-export default bubbleSort;
diff --git a/src/algorithms/mergeSort.js b/src/algorithms/mergeSort.js
deleted file mode 100644
index 6fa9b4f..0000000
--- a/src/algorithms/mergeSort.js
+++ /dev/null
@@ -1,67 +0,0 @@
-import { insertStep } from "../helpers/helpers.js";
-
-function mergeSort(array, position, arraySteps, colorSteps) {
- if (array.length === 1) return array;
- let mid = Math.floor(array.length / 2);
-
- // Split and work recursively
- let arrayA = mergeSort(array.slice(0, mid), position, arraySteps, colorSteps);
- let arrayB = mergeSort(
- array.slice(mid),
- position + mid,
- arraySteps,
- colorSteps
- );
-
- let arrayNew = merge(arrayA, arrayB, position, arraySteps, colorSteps);
- arraySteps.push(arraySteps[arraySteps.length - 1].slice());
- colorSteps.push(
- colorSteps[colorSteps.length - 1].fill(
- arrayNew.length === arraySteps[0].length ? 2 : 0
- )
- );
- return arrayNew;
-}
-
-const merge = (arrayA, arrayB, position, arraySteps, colorSteps) => {
- let arrayNew = [];
- let A = 0;
- let B = 0;
-
- while (arrayA.length > 0 && arrayB.length > 0) {
- if (arrayA[A] < arrayB[B]) {
- arrayNew.push(arrayA.shift());
- insertStep(arrayNew, position, arraySteps);
- } else {
- arrayNew.push(arrayB.shift());
- insertStep(arrayNew, position, arraySteps);
- }
- updateColor(position, colorSteps, arrayNew.length - 1, [], []);
- }
-
- // concatenate remaining values
-
- if (arrayA.length !== 0 || arrayB.length !== 0) {
- updateColor(position, colorSteps, arrayNew.length, arrayA, arrayB);
- arrayNew = arrayNew.concat(arrayA);
- arrayNew = arrayNew.concat(arrayB);
- insertStep(arrayNew, position, arraySteps);
- }
-
- return arrayNew;
-};
-
-function updateColor(position, colorSteps, start, arrayA, arrayB) {
- let colorKey = colorSteps[colorSteps.length - 1].slice();
- let end = position + start + arrayA.length + arrayB.length;
- start = start + position;
-
- if (end === start) {
- colorKey.fill(1, start, end + 1);
- } else {
- colorKey.fill(1, start, end);
- }
- colorSteps.push(colorKey);
-}
-
-export default mergeSort;
diff --git a/src/algorithms/quickSort.js b/src/algorithms/quickSort.js
deleted file mode 100644
index 4aa0d16..0000000
--- a/src/algorithms/quickSort.js
+++ /dev/null
@@ -1,80 +0,0 @@
-import { swap, insertStep } from "../helpers/helpers.js";
-
-const quickSort = (array, position, arraySteps, colorSteps) => {
- if (array.length < 2) {
- insertStep(array, position, arraySteps);
-
- let colorKey = colorSteps[colorSteps.length - 1].slice();
- colorKey[position] = 2;
- colorSteps.push(colorKey);
- return;
- }
-
- // pick median of three numbers as pivot and sent it to back
- swap(array, pickPivot(array), array.length - 1);
- insertStep(array, position, arraySteps);
- colorSteps.push(colorSteps[colorSteps.length - 1].slice());
-
- let pivot = array[array.length - 1];
- let A = 0;
- let B = array.length - 1;
-
- // swap small value from right with big value from left
- while (A < B) {
- while (array[A] < pivot) {
- insertStep(array, position, arraySteps);
- let colorKey = colorSteps[colorSteps.length - 1].slice();
- colorKey = colorKey.map((key) => (key === 2 ? 2 : 0));
- colorKey[position + A] = 1;
- colorKey[position + B] = 1;
- colorSteps.push(colorKey);
- A++;
- }
- while (array[B] >= pivot) {
- insertStep(array, position, arraySteps);
- let colorKey = colorSteps[colorSteps.length - 1].slice();
- colorKey = colorKey.map((key) => (key === 2 ? 2 : 0));
- colorKey[position + A] = 1;
- colorKey[position + B] = 1;
- colorSteps.push(colorKey);
- B--;
- }
- if (A < B) {
- swap(array, A, B);
- insertStep(array, position, arraySteps);
- let colorKey = colorSteps[colorSteps.length - 1].slice();
- colorKey = colorKey.map((key) => (key === 2 ? 2 : 0));
- colorKey[position + A] = 1;
- colorKey[position + B] = 1;
- colorSteps.push(colorKey);
- }
- }
-
- // swap big value with pivot
- let bigIndex = Math.max(A, B);
-
- swap(array, bigIndex, array.length - 1);
- insertStep(array, position, arraySteps);
- let colorKey = colorSteps[colorSteps.length - 1].slice();
- colorKey[position + bigIndex] = 2;
- colorSteps.push(colorKey);
-
- // recurse on two halves
- quickSort(array.slice(0, A), position, arraySteps, colorSteps);
- quickSort(array.slice(A + 1), position + A + 1, arraySteps, colorSteps);
-
- return;
-};
-
-function pickPivot(array) {
- let A = array[0];
- let B = array[Math.floor(array.length / 2)];
- let C = array[array.length - 1];
-
- let middleValue = [A, B, C].sort()[1];
- let middleIndex = array.indexOf(middleValue);
-
- return middleIndex;
-}
-
-export default quickSort;
diff --git a/src/components/Bar.css b/src/components/Bar.css
deleted file mode 100644
index 07c5a3a..0000000
--- a/src/components/Bar.css
+++ /dev/null
@@ -1,5 +0,0 @@
-.bar {
- background: black;
- margin: 2.5px;
- width: 5px;
-}
diff --git a/src/components/Bar.js b/src/components/Bar.js
deleted file mode 100644
index d0c0b59..0000000
--- a/src/components/Bar.js
+++ /dev/null
@@ -1,19 +0,0 @@
-import React from "react";
-import "./Bar.css";
-
-export default function Bar({ length, colorKey }) {
- const COLOR_SET = ["lightgrey", "grey", "#F51057"];
-
- let color = COLOR_SET[colorKey];
-
- let style = {
- height: length,
- backgroundColor: color,
- };
-
- return (
- <>
-
-
- );
-}
diff --git a/src/components/Counter.js b/src/components/Counter.js
deleted file mode 100644
index e83517c..0000000
--- a/src/components/Counter.js
+++ /dev/null
@@ -1,27 +0,0 @@
-import React from "react";
-
-export default class Counter extends React.Component {
- constructor(props) {
- super(props);
- this.state = {
- array: [],
- };
- }
-
- resetArray() {
- const array = [];
- for (let i = 0; i < 100; i++) {
- array.push(Math.floor(Math.random() * 100));
- }
- this.setState(array);
- }
-
- render() {
- const array = this.state;
- return (
-