From 0d919fd80b95033f8a44a18cc377e594fe424708 Mon Sep 17 00:00:00 2001
From: sarthakgupta1907-cell <sarthakgupta1907@gmail.com>
Date: Sat, 7 Nov 2026 11:06:57 +0530
Subject: [PATCH] feat: add additive persistence algorithm

---
 Maths/AdditivePersistence.js           | 28 ++++++++++++++
 Maths/test/AdditivePersistence.test.js | 51 ++++++++++++++++++++++++++
 2 files changed, 79 insertions(+)
 create mode 100644 Maths/AdditivePersistence.js
 create mode 100644 Maths/test/AdditivePersistence.test.js

diff --git a/Maths/AdditivePersistence.js b/Maths/AdditivePersistence.js
new file mode 100644
index 0000000000..713fe7a646
--- /dev/null
+++ b/Maths/AdditivePersistence.js
@@ -0,0 +1,28 @@
+/**
+ * @function additivePersistence
+ * @description Additive persistence is the number of times you must
+ *   add the digits of a number until you reach a single digit.
+ *   For example, 1679: 1+6+7+9=23, 2+3=5 — persistence is 2.
+ * @param {number} n - A non-negative integer
+ * @returns {number} - The additive persistence of n
+ * @see https://en.wikipedia.org/wiki/Persistence_of_a_number
+ * @example additivePersistence(1679) => 2
+ * @example additivePersistence(199) => 3
+ * @example additivePersistence(5) => 0
+ */
+const additivePersistence = (n) => {
+  if (!Number.isInteger(n) || n < 0) {
+    throw new TypeError('Input must be a non-negative integer')
+  }
+  let count = 0
+  let current = n
+  while (current >= 10) {
+    current = String(current)
+      .split('')
+      .reduce((sum, d) => sum + Number(d), 0)
+    count++
+  }
+  return count
+}
+
+export { additivePersistence }
diff --git a/Maths/test/AdditivePersistence.test.js b/Maths/test/AdditivePersistence.test.js
new file mode 100644
index 0000000000..1a1b2862b3
--- /dev/null
+++ b/Maths/test/AdditivePersistence.test.js
@@ -0,0 +1,51 @@
+import { additivePersistence } from '../AdditivePersistence.js'
+
+describe('additivePersistence', () => {
+  test('single digit returns 0', () => {
+    expect(additivePersistence(5)).toBe(0)
+  })
+
+  test('additivePersistence(0) returns 0', () => {
+    expect(additivePersistence(0)).toBe(0)
+  })
+
+  test('additivePersistence(10) returns 1', () => {
+    expect(additivePersistence(10)).toBe(1)
+  })
+
+  test('additivePersistence(99) returns 2', () => {
+    expect(additivePersistence(99)).toBe(2)
+  })
+
+  test('additivePersistence(1679) returns 2', () => {
+    expect(additivePersistence(1679)).toBe(2)
+  })
+
+  test('additivePersistence(199) returns 3', () => {
+    expect(additivePersistence(199)).toBe(3)
+  })
+
+  test('additivePersistence(1999999) returns 3', () => {
+    expect(additivePersistence(1999999)).toBe(3)
+  })
+
+  test('additivePersistence(100) returns 1', () => {
+    expect(additivePersistence(100)).toBe(1)
+  })
+
+  test('additivePersistence(23) returns 1', () => {
+    expect(additivePersistence(23)).toBe(1)
+  })
+
+  test('throws TypeError for negative input', () => {
+    expect(() => additivePersistence(-199)).toThrow(TypeError)
+  })
+
+  test('throws TypeError for float input', () => {
+    expect(() => additivePersistence(1.5)).toThrow(TypeError)
+  })
+
+  test('throws TypeError for string input', () => {
+    expect(() => additivePersistence('199')).toThrow(TypeError)
+  })
+})