feat: Hamming Code for 32bit values #1431

Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,34 @@
	/**
	* github author: chrdek
	* license: GPL-3.0 or later
	*
	* @param {number} b = integer or, binary representation of it
	*
	* The following code generates the hamming code for a binary sequence
	* of 32-bit integer values (incl. parity bit check)
	*
	* Returns the overall of bit count population for values up to 65535, inclusive
	*
	**/

	function HammingCode(b) {
	//preallocate total number of integers to count the bits population from.
	let bytes = new Array(65536);
	const bitAlloc = (bin) => {
	let counter = 0;
	while (bin > 0) {
	counter += bin & 1;
	bin >>=1;
	}
	return counter;
	}

	//count all 1-bits from entire bit set
	for (let k=0; k < 65536; k++)
	bytes[k] = bitAlloc(k);

	//perform bit shifting for integer values for bit-populated result
	return bytes[b & 0xFFFF] + bytes[b >> 16];
	}

	export { HammingCode }

14 changes: 14 additions & 0 deletions Bit-Manipulation/test/HammingCode.test.js

Show comments View file Open in desktop

Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,14 @@
	import { HammingCode } from '../HammingCode'

	describe.each([
	{ inputVal:Number(117), expectedVal: 5 },
	{ inputVal:parseInt(0x9F9,16), expectedVal: 7 },
	{ inputVal:parseInt(0x889193,16), expectedVal: 10 },
	{ inputVal:10043091, expectedVal: 14},
	{ inputVal:parseInt("1101110",2), expectedVal: 5 },
	{ inputVal:parseInt(1101110,2), expectedVal: 5 }
	])('Resulting hamming code conversion from $inputVal', ({inputVal, expectedVal}) => {
	test(`returns bit count = ${expectedVal}`, () => {
	expect(HammingCode(inputVal)).toBe(expectedVal)
	})
	})

39 changes: 39 additions & 0 deletions Maths/TriangularNumberCheck.js

Show comments View file Open in desktop

Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,39 @@
	/**
	* github author: chrdek
	* license: GPL-3.0 or later
	*
	* @param {number} n = number to be determined whether is a triangular or not
	*
	* The function below is a mathematical algorithm to check if a given number n is a triangular number.
	* A triangular number is one that can be represented
	* in the form of the sum of consecutive positive integers starting from 1.
	*
	* Returns -1 for error input or negative numerical input, 0 for non-triangular
	* and an integer value if the number is triangular.
	*
	* The variable discriminant is calculated as the square root of (1 + 8 * n) and then its square root is taken again.
	* The expression Math.sqrt(1 + 8 * n) is the discriminant of the quadratic equation that represents triangular numbers.
	*
	**/

	function TriangularNumberCheck(n) {
	// Ensure the input n is a non-negative integer, retrurn -1 to indicate error.
	if (!Number.isInteger(n) \|\| n < 0) {
	return -1;
	}

	// Calculate the discriminant of the quadratic equation
	const discriminant = Math.sqrt(1 + 8 * n);

	// Check if the discriminant is an integer
	if (discriminant % 1 === 0) {

	// Return half of the integer value of the discriminant
	return Math.floor(discriminant / 2);
	} else {
	// If not a triangular number, return 0
	return 0;
	}
	}

	export { TriangularNumberCheck }

39 changes: 39 additions & 0 deletions Maths/test/TriangularNumberCheck.test.js

Show comments View file Open in desktop

Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,39 @@
	import { TriangularNumberCheck } from '../TriangularNumberCheck'

	describe.each([
	{ inputVal:55, expectedVal:10 },
	{ inputVal:45, expectedVal:9 },
	{ inputVal:190, expectedVal:19 },
	{ inputVal:66, expectedVal:11 },
	{ inputVal:666, expectedVal:36 },
	{ inputVal:6, expectedVal:3 },
	{ inputVal:10, expectedVal:4 },
	{ inputVal:1, expectedVal:1 },
	])('If the number of $inputVal is triangular', ({inputVal, expectedVal}) => {
	test(`should return ${expectedVal}`, () => {
	expect(TriangularNumberCheck(inputVal)).toBe(expectedVal)
	})
	})

	describe.each([
	{ inputVal:-1, expectedVal:-1 },
	{ inputVal:-10, expectedVal:-1 },
	{ inputVal:-9, expectedVal:-1 },
	{ inputVal:"foo", expectedVal:-1 },
	{ inputVal:"fizz", expectedVal:-1 },
	])('If the number of $inputVal is completely wrong or negative', ({inputVal, expectedVal}) => {
	test(`should return ${expectedVal}`, () => {
	expect(TriangularNumberCheck(inputVal)).not.toBeLessThan(-1)
	})
	})

	describe.each([
	{ inputVal:4183059834009, expectedVal:0 },
	{ inputVal:69, expectedVal:0 },
	{ inputVal:0, expectedVal:0 },
	{ inputVal:23, expectedVal:0 }
	])('If the number of $inputVal is NOT triangular', ({inputVal, expectedVal}) => {
	test(`should return ${expectedVal}`, () => {
	expect(TriangularNumberCheck(inputVal)).toBe(0)
	})
	})

Navigation Menu