sortism 1.0.0 → 1.2.0

package/README.md

@@ -1,6 +1,9 @@
 # sortism
 
-![license](https://img.shields.io/npm/l/sortism) ![stars](https://img.shields.io/github/stars/Pro203S/sortism)
+[ENGLISH](./README_EN.md)
+
+![license](https://img.shields.io/npm/l/sortism)
+![stars](https://img.shields.io/github/stars/Pro203S/sortism)
 
 자신에게 맞는 방법으로 배열을 정렬해보세요!  
 이 모듈에는 여러가지의 정렬 방식이 있습니다.  

package/README_EN.md

@@ -0,0 +1,89 @@
+# sortism
+
+![license](https://img.shields.io/npm/l/sortism)
+![stars](https://img.shields.io/github/stars/Pro203S/sortism)
+
+Sort arrays in the way that suits you best!  
+This module provides various sorting methods.  
+Just choose the one that fits your needs.
+
+## Usage
+
+1. Install the package
+
+``` sh
+npm i sortism
+
+bun i sortism
+```
+
+2. Import the module
+
+``` typescript
+import sortism from 'sortism';
+```
+
+3. Use sorting
+
+``` typescript
+const arr = [5, 2, 3, 1, 4];
+
+// Bubble sort, ascending
+// 1,2,3,4,5
+sortism(arr).bubble("ascending");
+
+// Selection sort, descending
+// 5,4,3,2,1
+sortism(arr).selection("descending");
+```
+
+## Detailed Usage
+
+-  Sorting objects
+
+```typescript
+const arr = [
+    {
+        "index": 2
+    },
+    {
+        "index": 0
+    },
+    {
+        "index": 2
+    },
+    {
+        "index": 6
+    },
+    {
+        "index": 4
+    },
+    {
+        "index": 3
+    }
+];
+
+// Bubble sort, ascending
+sortism(arr).bubble("ascending");
+
+/*
+returns:
+[
+  {
+    index: 0,
+  }, {
+    index: 2,
+  }, {
+    index: 2,
+  }, {
+    index: 3,
+  }, {
+    index: 4,
+  }, {
+    index: 6,
+  }
+]
+*/
+```
+
+Install it now and start using it!

package/dist/index.d.ts

@@ -20,4 +20,20 @@ export default function sortism<T = any>(array: T[], func?: (v: T) => number): {
      * Time: O(n log n)
      */
     quick: ExportSortFunction<T>;
+    /**
+     * Time: O(n * n!)
+     */
+    bogo: ExportSortFunction<T>;
+    /**
+     * Time: O(N)
+     */
+    stalin: ExportSortFunction<T>;
+    /**
+     * Time: O(Infinity)
+     */
+    miracle: ExportSortFunction<T>;
+    /**
+     * Time: O(N)
+     */
+    thanos: ExportSortFunction<T>;
 };

package/dist/index.js

@@ -1,7 +1,11 @@
+import bogo from "./sorts/bogo";
 import bubble from "./sorts/bubble";
 import merge from "./sorts/merge";
+import miracle from "./sorts/miracle";
 import quick from "./sorts/quick";
 import selection from "./sorts/selection";
+import stalin from "./sorts/stalin";
+import thanos from "./sorts/thanos";
 /**
  * You can use sortism through this function.
  */
@@ -24,5 +28,21 @@ export default function sortism(array, func) {
          * Time: O(n log n)
          */
         "quick": (order => quick(array, f, order)),
+        /**
+         * Time: O(n * n!)
+         */
+        "bogo": (order => bogo(array, f, order)),
+        /**
+         * Time: O(N)
+         */
+        "stalin": (order => stalin(array, f, order)),
+        /**
+         * Time: O(Infinity)
+         */
+        "miracle": (order => miracle(array, f, order)),
+        /**
+         * Time: O(N)
+         */
+        "thanos": (order => thanos(array, f, order)),
     };
 }

package/dist/sorts/bogo.d.ts

@@ -0,0 +1,3 @@
+import type { InternalSortFunction } from "..";
+declare const bogo: InternalSortFunction;
+export default bogo;

package/dist/sorts/bogo.js

@@ -0,0 +1,32 @@
+const bogo = (arr, func, order) => {
+    const indexMap = arr.map(v => ({
+        index: func(v),
+        value: v
+    }));
+    const isAsc = order === "ascending";
+    const isSorted = (array) => {
+        for (let i = 0; i < array.length - 1; i++) {
+            const current = array[i];
+            const next = array[i + 1];
+            const isValid = isAsc
+                ? current.index <= next.index
+                : current.index >= next.index;
+            if (!isValid)
+                return false;
+        }
+        return true;
+    };
+    const shuffle = (array) => {
+        for (let i = array.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            const temp = array[i];
+            array[i] = array[j];
+            array[j] = temp;
+        }
+    };
+    while (!isSorted(indexMap)) {
+        shuffle(indexMap);
+    }
+    return indexMap.map(v => v.value);
+};
+export default bogo;

package/dist/sorts/miracle.d.ts

@@ -0,0 +1,3 @@
+import type { InternalSortFunction } from "..";
+declare const miracle: InternalSortFunction;
+export default miracle;

package/dist/sorts/miracle.js

@@ -0,0 +1,22 @@
+const miracle = (arr, func, order) => {
+    const indexMap = arr.map(v => ({
+        index: func(v),
+        value: v
+    }));
+    const isAsc = order === "ascending";
+    const isSorted = (array) => {
+        for (let i = 0; i < array.length - 1; i++) {
+            const current = array[i];
+            const next = array[i + 1];
+            const isValid = isAsc
+                ? current.index <= next.index
+                : current.index >= next.index;
+            if (!isValid)
+                return false;
+        }
+        return true;
+    };
+    while (!isSorted(indexMap)) { }
+    return indexMap.map(v => v.value);
+};
+export default miracle;

package/dist/sorts/stalin.d.ts

@@ -0,0 +1,3 @@
+import type { InternalSortFunction } from "..";
+declare const stalin: InternalSortFunction;
+export default stalin;

package/dist/sorts/stalin.js

@@ -0,0 +1,22 @@
+const stalin = (arr, func, order) => {
+    const indexMap = arr.map(v => ({
+        index: func(v),
+        value: v
+    }));
+    const isAsc = order === "ascending";
+    if (indexMap.length === 0)
+        return [];
+    const result = [indexMap[0]];
+    for (let i = 1; i < indexMap.length; i++) {
+        const current = indexMap[i];
+        const last = result[result.length - 1];
+        const shouldKeep = isAsc
+            ? current.index >= last.index
+            : current.index <= last.index;
+        if (shouldKeep) {
+            result.push(current);
+        }
+    }
+    return result.map(v => v.value);
+};
+export default stalin;

package/dist/sorts/thanos.d.ts

@@ -0,0 +1,3 @@
+import type { InternalSortFunction } from "..";
+declare const thanos: InternalSortFunction;
+export default thanos;

package/dist/sorts/thanos.js

@@ -0,0 +1,33 @@
+const thanos = (arr, func, order) => {
+    let indexMap = arr.map(v => ({
+        index: func(v),
+        value: v
+    }));
+    const isAsc = order === "ascending";
+    const isSorted = (array) => {
+        for (let i = 0; i < array.length - 1; i++) {
+            const current = array[i];
+            const next = array[i + 1];
+            const isValid = isAsc
+                ? current.index <= next.index
+                : current.index >= next.index;
+            if (!isValid)
+                return false;
+        }
+        return true;
+    };
+    const snap = (array) => {
+        const result = [];
+        for (let i = 0; i < array.length; i++) {
+            if (Math.random() < 0.5) {
+                result.push(array[i]);
+            }
+        }
+        return result;
+    };
+    while (!isSorted(indexMap)) {
+        indexMap = snap(indexMap);
+    }
+    return indexMap.map(v => v.value);
+};
+export default thanos;

package/package.json

@@ -2,7 +2,7 @@
   "name": "sortism",
   "description": "The easiest way to sort an array.",
   "main": "./dist/index.js",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "type": "module",
   "keywords": [
     "sort",

package/src/index.ts

@@ -1,7 +1,11 @@
+import bogo from "./sorts/bogo";
 import bubble from "./sorts/bubble";
 import merge from "./sorts/merge";
+import miracle from "./sorts/miracle";
 import quick from "./sorts/quick";
 import selection from "./sorts/selection";
+import stalin from "./sorts/stalin";
+import thanos from "./sorts/thanos";
 
 export type InternalSortFunction = <T>(
     arr: T[],
@@ -37,5 +41,21 @@ export default function sortism<T = any>(array: T[], func?: (v: T) => number) {
          * Time: O(n log n)
          */
         "quick": (order => quick(array, f, order)) as ExportSortFunction<T>,
+        /**
+         * Time: O(n * n!)
+         */
+        "bogo": (order => bogo(array, f, order)) as ExportSortFunction<T>,
+        /**
+         * Time: O(N)
+         */
+        "stalin": (order => stalin(array, f, order)) as ExportSortFunction<T>,
+        /**
+         * Time: O(Infinity)
+         */
+        "miracle": (order => miracle(array, f, order)) as ExportSortFunction<T>,
+        /**
+         * Time: O(N)
+         */
+        "thanos": (order => thanos(array, f, order)) as ExportSortFunction<T>,
     };
 }

package/src/sorts/bogo.ts

@@ -0,0 +1,42 @@
+import type { InternalSortFunction } from "..";
+
+const bogo: InternalSortFunction = (arr, func, order) => {
+    const indexMap = arr.map(v => ({
+        index: func(v),
+        value: v
+    }));
+
+    const isAsc = order === "ascending";
+
+    const isSorted = (array: typeof indexMap): boolean => {
+        for (let i = 0; i < array.length - 1; i++) {
+            const current = array[i]!;
+            const next = array[i + 1]!;
+
+            const isValid = isAsc
+                ? current.index <= next.index
+                : current.index >= next.index;
+
+            if (!isValid) return false;
+        }
+        return true;
+    };
+
+    const shuffle = (array: typeof indexMap): void => {
+        for (let i = array.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+
+            const temp = array[i]!;
+            array[i] = array[j]!;
+            array[j] = temp;
+        }
+    };
+
+    while (!isSorted(indexMap)) {
+        shuffle(indexMap);
+    }
+
+    return indexMap.map(v => v.value);
+};
+
+export default bogo;

package/src/sorts/miracle.ts

@@ -0,0 +1,30 @@
+import type { InternalSortFunction } from "..";
+
+const miracle: InternalSortFunction = (arr, func, order) => {
+    const indexMap = arr.map(v => ({
+        index: func(v),
+        value: v
+    }));
+
+    const isAsc = order === "ascending";
+
+    const isSorted = (array: typeof indexMap): boolean => {
+        for (let i = 0; i < array.length - 1; i++) {
+            const current = array[i]!;
+            const next = array[i + 1]!;
+
+            const isValid = isAsc
+                ? current.index <= next.index
+                : current.index >= next.index;
+
+            if (!isValid) return false;
+        }
+        return true;
+    };
+
+    while (!isSorted(indexMap)) { }
+
+    return indexMap.map(v => v.value);
+};
+
+export default miracle;

package/src/sorts/stalin.ts

@@ -0,0 +1,31 @@
+import type { InternalSortFunction } from "..";
+
+const stalin: InternalSortFunction = (arr, func, order) => {
+    const indexMap = arr.map(v => ({
+        index: func(v),
+        value: v
+    }));
+
+    const isAsc = order === "ascending";
+
+    if (indexMap.length === 0) return [];
+
+    const result: typeof indexMap = [indexMap[0]!];
+
+    for (let i = 1; i < indexMap.length; i++) {
+        const current = indexMap[i]!;
+        const last = result[result.length - 1]!;
+
+        const shouldKeep = isAsc
+            ? current.index >= last.index
+            : current.index <= last.index;
+
+        if (shouldKeep) {
+            result.push(current);
+        }
+    }
+
+    return result.map(v => v.value);
+};
+
+export default stalin;

package/src/sorts/thanos.ts

@@ -0,0 +1,44 @@
+import type { InternalSortFunction } from "..";
+
+const thanos: InternalSortFunction = (arr, func, order) => {
+    let indexMap = arr.map(v => ({
+        index: func(v),
+        value: v
+    }));
+
+    const isAsc = order === "ascending";
+
+    const isSorted = (array: typeof indexMap): boolean => {
+        for (let i = 0; i < array.length - 1; i++) {
+            const current = array[i]!;
+            const next = array[i + 1]!;
+
+            const isValid = isAsc
+                ? current.index <= next.index
+                : current.index >= next.index;
+
+            if (!isValid) return false;
+        }
+        return true;
+    };
+
+    const snap = (array: typeof indexMap): typeof indexMap => {
+        const result: typeof indexMap = [];
+
+        for (let i = 0; i < array.length; i++) {
+            if (Math.random() < 0.5) {
+                result.push(array[i]!);
+            }
+        }
+
+        return result;
+    };
+
+    while (!isSorted(indexMap)) {
+        indexMap = snap(indexMap);
+    }
+
+    return indexMap.map(v => v.value);
+};
+
+export default thanos;

package/tests/index.ts

@@ -1,27 +1,8 @@
 import sortism from './../dist';
 
-const arr = [
-    {
-        "index": 0
-    },
-    {
-        "index": 2
-    },
-    {
-        "index": 2
-    },
-    {
-        "index": 6
-    },
-    {
-        "index": 4
-    },
-    {
-        "index": 3
-    }
-];
-const sort = sortism(arr, (v) => v.index);
+const arr = [0,15,126,74,4,2234,235,23,574,4578,2];
+const sort = sortism(arr);
 
-const result = sort.selection("ascending");
+const result = sort.thanos("ascending");
 
 console.log(result);