solve 0415

Author: charliesbot

0415_add_strings/0415_add_strings.test.ts

@@ -0,0 +1,8 @@
+import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
+import { addStrings } from "./0415_add_strings.ts";
+
+Deno.test(function test1() {
+  const num1 = "1";
+  const num2 = "1";
+  assertEquals(addStrings(num1, num2), "2");
+});

0415_add_strings/0415_add_strings.ts

@@ -0,0 +1,37 @@
+/*
+ * Given two non-negative integers num1 and num2 represented as string, return the sum of num1 and num2.
+ *
+ * Note:
+ * - The length of both num1 and num2 is < 5100.
+ * - Both num1 and num2 contains only digits 0-9.
+ * - Both num1 and num2 does not contain any leading zero.
+ * - You must not use any built-in BigInteger library or convert the inputs to integer directly.
+ */
+
+const addStrings = (num1: string, num2: string): string => {
+  let num1Cursor = num1.length - 1;
+  let num2Cursor = num2.length - 1;
+  let result = "";
+
+  let carry = 0;
+
+  while (num1Cursor >= 0 || num2Cursor >= 0) {
+    const digit1 = parseInt(num1[num1Cursor]) || 0;
+    const digit2 = parseInt(num2[num2Cursor]) || 0;
+    const sum = digit1 + digit2 + carry;
+
+    carry = Math.floor(sum / 10);
+
+    result = (sum % 10).toString() + result;
+    num1Cursor--;
+    num2Cursor--;
+  }
+
+  if (carry > 0) {
+    result = `${carry}${result}`;
+  }
+
+  return result;
+};
+
+export { addStrings };

0973_k_closest_points_to_origin/0973_k_closest_points_to_origin.test.ts

@@ -0,0 +1,13 @@
+import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
+import { kClosest } from "./0973_k_closest_points_to_origin.ts";
+
+Deno.test(function test1() {
+  const points = [
+    [1, 3],
+    [-2, 2],
+  ];
+  const K = 1;
+  const output = [[-2, 2]];
+
+  assertEquals(kClosest(points, K), output);
+});

0973_k_closest_points_to_origin/0973_k_closest_points_to_origin.ts

@@ -0,0 +1,40 @@
+/*
+ * We have a list of points on the plane.
+ * Find the K closest points to the origin (0, 0).
+ *
+ * (Here, the distance between two points on a plane is the Euclidean distance.)
+ *
+ * You may return the answer in any order.
+ *
+ * The answer is guaranteed to be unique (except for the order that it is in.)
+ */
+
+type Args = {
+  x1: number;
+  y1: number;
+  x2: number;
+  y2: number;
+};
+
+const distanceBetweenPoints = ({ x1, y1, x2, y2 }: Args) => {
+  // d=√((x_2-x_1)²+(y_2-y_1)²)
+  return Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2);
+};
+
+const kClosest = (points: number[][], K: number): number[][] => {
+  const distances = [];
+
+  for (const currentPoints of points) {
+    const [x, y] = currentPoints;
+    distances.push({
+      points: currentPoints,
+      distance: distanceBetweenPoints({ x1: 0, y1: 0, x2: x, y2: y }),
+    });
+  }
+
+  distances.sort((a, b) => a.distance - b.distance);
+
+  return distances.slice(0, K).map((distances) => distances.points);
+};
+
+export { kClosest };