climbing_stairs_bigint,fibonacci_bigint,pow_bigint

Author: masx200

climbing-stairs/test.ts

@@ -1,5 +1,5 @@
 import { assertStrictEquals } from "../deps.ts";
-import { climbing_stairs } from "../mod.ts";
+import { climbing_stairs, climbing_stairs_bigint } from "../mod.ts";
 
 Deno.test("climbing-stairs", () => {
     const examples: {
@@ -19,3 +19,21 @@ Deno.test("climbing-stairs", () => {
         assertStrictEquals(climbing_stairs(input), output);
     });
 });
+Deno.test("climbing_stairs_bigint", () => {
+    const examples: {
+        input: Parameters<typeof climbing_stairs_bigint>[0];
+        output: ReturnType<typeof climbing_stairs_bigint>;
+    }[] = [
+        { input: 10n, output: 89n },
+        { input: 1n, output: 1n },
+        { input: 2n, output: 2n },
+        { input: 3n, output: 3n },
+        { input: 45n, output: 1836311903n },
+        { input: 44n, output: 1134903170n },
+        { input: 46n, output: 1134903170n + 1836311903n },
+        { input: 99n, output: 354224848179261915075n },
+    ];
+    examples.forEach(({ input, output }) => {
+        assertStrictEquals(climbing_stairs_bigint(input), output);
+    });
+});

fibonacci-number/test.ts

@@ -1,5 +1,5 @@
 import { assertStrictEquals } from "../deps.ts";
-import { fibonacci_Number } from "../mod.ts";
+import { fibonacci_bigint, fibonacci_Number } from "../mod.ts";
 
 Deno.test("fibonacci-number", () => {
     const examples: {
@@ -17,3 +17,21 @@ Deno.test("fibonacci-number", () => {
         assertStrictEquals(fibonacci_Number(input), output);
     });
 });
+Deno.test("fibonacci_bigint", () => {
+    const examples: {
+        input: Parameters<typeof fibonacci_bigint>[0];
+        output: ReturnType<typeof fibonacci_bigint>;
+    }[] = [
+        { input: 2n, output: 1n },
+        { input: 3n, output: 2n },
+        { input: 4n, output: 3n },
+        { input: 30n, output: 832040n },
+        { input: 20n, output: 6765n },
+        { input: 21n, output: 10946n },
+        { input: 22n, output: 6765n + 10946n },
+        { input: 99n, output: 218922995834555169026n },
+    ];
+    examples.forEach(({ input, output }) => {
+        assertStrictEquals(fibonacci_bigint(input), output);
+    });
+});

mod.ts

@@ -1,5 +1,6 @@
 import merge_Sorted_Array from "./merge-sorted-array/index.ts";
 import pow_x_n from "./powx-n/index.ts";
+export { pow_bigint } from "./powx-n/index.ts";
 
 import html_Entity_Parser from "./html-entity-parser/index.ts";
 

powx-n/index.ts

@@ -68,3 +68,34 @@ export default function myPow(x: number, n: number): number {
 //         return l * b();
 //     }
 // }
+export function pow_bigint(x: bigint, n: bigint): bigint {
+    if (n < 0) {
+        throw Error("result not bigint:" + x + "," + n);
+    }
+    const result = n === 1n
+        ? x
+        : x < 0
+        ? (n % 2n === 0n ? 1n : -1n) * pow_bigint(-x, n)
+        : x === 1n
+        ? 1n
+        : x === 0n
+        ? 0n
+        : n === 0n
+        ? 1n
+        : // : n < 0
+        // ? pow_bigint(1 / x, -n)
+            n % 2n
+            ? x * pow_bigint(x, n - 1n)
+            : /* lazyMultiplyPositive(
+                  () => x,
+                  () => myPow(x, n - 1)
+              ) */
+                pow_bigint(x * x, n / 2n);
+    /* lazyMultiplyPositive(
+            () => myPow(x, Math.floor(n / 2)),
+            () => myPow(x, n - Math.floor(n / 2)),
+        ); */
+
+    // cacheStore.set(`${x},${n}`, result);
+    return result;
+}

powx-n/test.ts

@@ -1,8 +1,8 @@
-import { assert } from "../deps.ts";
-import { pow_x_n } from "../mod.ts";
+import { assert, assertStrictEquals } from "../deps.ts";
+import { pow_bigint, pow_x_n } from "../mod.ts";
 import { float64equals } from "../utils/float64equals.ts";
 
-Deno.test("powx-n", () => {
+Deno.test("pow_x-n", () => {
     const examples: {
         input: Parameters<typeof pow_x_n>;
         output: ReturnType<typeof pow_x_n>;
@@ -42,3 +42,29 @@ Deno.test("powx-n", () => {
         assert(float64equals(output, pow_x_n(...input)));
     });
 });
+Deno.test("pow_bigint", () => {
+    const examples: {
+        input: Parameters<typeof pow_bigint>;
+        output: ReturnType<typeof pow_bigint>;
+    }[] = [
+        { input: [BigInt(2), 10n], output: BigInt(1024.0) },
+        {
+            input: [100n, 100n],
+            output:
+                100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000n,
+        },
+
+        {
+            input: [2n, 6n],
+            output: BigInt(64.0),
+        },
+        {
+            input: [688n, 68n],
+            output:
+                9036781882805851290639597927040482406482157574559116099548211283603471044068107755100184208020371364454930798169267683149572972315418389823766231220691565768687216159600116784986771438012727296n,
+        },
+    ];
+    examples.forEach(({ input, output }) => {
+        assertStrictEquals(output, pow_bigint(...input));
+    });
+});