Adding some more algorithms in javascript.

2022/03/algorithms/append_delete_bfs.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const fs = require('fs');
+
+process.stdin.resume();
+process.stdin.setEncoding('utf-8');
+
+let inputString = '';
+let currentLine = 0;
+
+process.stdin.on('data', function(inputStdin) {
+    inputString += inputStdin;
+});
+
+process.stdin.on('end', function() {
+    inputString = inputString.split('\n');
+
+    main();
+});
+
+process.on('SIGINT', function() {
+    inputString = inputString.split('\n');
+
+    main();
+    process.exit(0);
+});
+
+function readLine() {
+    return inputString[currentLine++];
+}
+
+/*
+ * Complete the 'appendAndDelete' function below.
+ *
+ * The function is expected to return a STRING.
+ * The function accepts following parameters:
+ *  1. STRING s
+ *  2. STRING t
+ *  3. INTEGER k
+ */
+
+function appendAndDelete(s, t, k) {
+    let max = 0, res;
+    s = s.trim();
+    t = t.trim();
+    // console.log(`s: ${s}, t: ${t}`);
+
+    let queue = [[s, 0]];
+    while (queue.length) {
+        let [word, steps] = queue.pop();
+        // console.log(`Word: ${word}, steps: ${steps}`);
+        if (word === t && steps === k) {
+            // console.log('Yes');
+            return "Yes";
+        }
+
+        if (steps >= k) {
+            continue;
+        }
+        queue.unshift([word.length ? word.slice(0, word.length - 1): '', steps+1]);
+        let increment = word.length >= t.length ? 'x' : t[word.length];
+        queue.unshift([word + increment, steps+1]);
+    }
+
+    // console.log('No');
+
+    return "No";
+
+}
+
+function main() {
+    const ws = fs.createWriteStream(process.env.OUTPUT_PATH);
+
+    const s = readLine();
+
+    const t = readLine();
+
+    const k = parseInt(readLine().trim(), 10);
+
+    const result = appendAndDelete(s, t, k);
+
+    ws.write(result + '\n');
+
+    ws.end();
+}

2022/03/algorithms/append_delete_final.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const fs = require('fs');
+
+process.stdin.resume();
+process.stdin.setEncoding('utf-8');
+
+let inputString = '';
+let currentLine = 0;
+
+process.stdin.on('data', function(inputStdin) {
+    inputString += inputStdin;
+});
+
+process.stdin.on('end', function() {
+    inputString = inputString.split('\n');
+
+    main();
+});
+
+process.on('SIGINT', function() {
+    inputString = inputString.split('\n');
+
+    main();
+    process.exit(0);
+});
+
+function readLine() {
+    return inputString[currentLine++];
+}
+
+/*
+ * Complete the 'appendAndDelete' function below.
+ *
+ * The function is expected to return a STRING.
+ * The function accepts following parameters:
+ *  1. STRING s
+ *  2. STRING t
+ *  3. INTEGER k
+ */
+
+function appendAndDelete(s, t, k) {
+    let max = 0, res;
+    s = s.trim();
+    t = t.trim();
+    for (let i = 0; i < Math.min(s.length, t.length); i++) {
+        if (s[i] !== t[i]) {
+            break;
+        } else {
+            max = i+1;
+        }
+    }
+
+
+    // console.log(`Max: ${max}`);
+
+    let operations = (s.length - max) + (t.length - max);
+    let operations2 = s.length + t.length;
+    console.log('Operations', operations);
+
+    return k >= operations2 || (k >= operations && (operations - k) % 2 == 0) ? 'Yes' : 'No';
+
+}
+
+function main() {
+    const ws = fs.createWriteStream(process.env.OUTPUT_PATH);
+
+    const s = readLine();
+
+    const t = readLine();
+
+    const k = parseInt(readLine().trim(), 10);
+
+    const result = appendAndDelete(s, t, k);
+
+    ws.write(result + '\n');
+
+    ws.end();
+}

2022/03/algorithms/append_delete_opt.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const fs = require('fs');
+
+process.stdin.resume();
+process.stdin.setEncoding('utf-8');
+
+let inputString = '';
+let currentLine = 0;
+
+process.stdin.on('data', function(inputStdin) {
+    inputString += inputStdin;
+});
+
+process.stdin.on('end', function() {
+    inputString = inputString.split('\n');
+
+    main();
+});
+
+process.on('SIGINT', function() {
+    inputString = inputString.split('\n');
+
+    main();
+    process.exit(0);
+});
+
+function readLine() {
+    return inputString[currentLine++];
+}
+
+/*
+ * Complete the 'appendAndDelete' function below.
+ *
+ * The function is expected to return a STRING.
+ * The function accepts following parameters:
+ *  1. STRING s
+ *  2. STRING t
+ *  3. INTEGER k
+ */
+
+function appendAndDelete(s, t, k) {
+    let max = 0, res;
+    s = s.trim();
+    t = t.trim();
+    for (let i = 0; i < Math.min(s.length, t.length); i++) {
+        if (s[i] !== t[i]) {
+            break;
+        } else {
+            max = i+1;
+        }
+    }
+
+
+    // console.log(`Max: ${max}`);
+
+    let operations = (s.length - max) + (t.length - max);
+    console.log('Operations', operations);
+
+    return operations === k ? 'Yes' : 'No';
+
+}
+
+function main() {
+    const ws = fs.createWriteStream(process.env.OUTPUT_PATH);
+
+    const s = readLine();
+
+    const t = readLine();
+
+    const k = parseInt(readLine().trim(), 10);
+
+    const result = appendAndDelete(s, t, k);
+
+    ws.write(result + '\n');
+
+    ws.end();
+}

2022/03/algorithms/btree.js

@@ -118,6 +118,41 @@ function display_tree(t, path = '') {
 	display_tree(t.children[t.keys.length], path + "/" + t.keys.length);
 }
 
+function btree_delete(t, el) {
+	console.log(`Got t`, t, `, el: ${el}`);
+	if (!t) {
+		return t;
+	}
+
+	let idx = binary_search(t.keys, el);
+	let val = t.keys[idx];
+	console.log(`Got index ${idx} with value ${t.keys[idx]}`);
+	if (t.keys[idx] === el || t.keys[idx-1] === el) {
+		// we need to delete this element
+		console.log(`Found key ${el}`);
+		let idxEl = t.keys[idx] === el ? idx : idx - 1;
+		console.log(`Found idx ${idxEl}`);
+
+		if (!t.children[idx]) {
+			t.keys.splice(idxEl, 1);
+			t.children.splice(idxEl, 1);
+		} else {
+			if (t[idx-1].keys >= t.level/2) {
+				// we can borrow one element from precedessing
+			} else if (t[idx+1].keys >= t.level/2) {
+				// we can borrow one element from successor
+			} else {
+				
+			}
+		}
+
+		// TODO check if there are enough elements to be balanced
+
+	} else {
+		return btree_delete(t.children[idx], el);
+	}
+}
+
 // let arr = [1, 3, 5, 7];
 
 // const el = -2;
@@ -125,7 +160,7 @@ function display_tree(t, path = '') {
 // arr.splice(pos, 0, el);
 // log(`Binary search`, arr);
 
-let t = make_node(2);
+// let t = make_node(2);
 // t = make_tree(t, btree_insert(t, 1));
 // t = make_tree(t, btree_insert(t, 2));
 // t = make_tree(t, btree_insert(t, 3));
@@ -134,8 +169,25 @@ let t = make_node(2);
 // t = make_tree(t, btree_insert(t, 6));
 // t = make_tree(t, btree_insert(t, 7));
 
-display_tree(t);
+// display_tree(t);
 // enable_logging = true;
+// t = make_tree(t, btree_insert(t, 1));
+// t = make_tree(t, btree_insert(t, 2));
+// t = make_tree(t, btree_insert(t, 3));
+// t = make_tree(t, btree_insert(t, 4));
+// t = make_tree(t, btree_insert(t, 5));
+// t = make_tree(t, btree_insert(t, 6));
+// t = make_tree(t, btree_insert(t, 7));
+// t = make_tree(t, btree_insert(t, 8));
+// t = make_tree(t, btree_insert(t, 5));
+// t = make_tree(t, btree_insert(t, 5));
+// console.log(t);
+//enable_logging = false;
+// display_tree(t);
+
+let t = make_node(4);
+
+enable_logging = false;
 t = make_tree(t, btree_insert(t, 1));
 t = make_tree(t, btree_insert(t, 2));
 t = make_tree(t, btree_insert(t, 3));
@@ -143,9 +195,9 @@ t = make_tree(t, btree_insert(t, 4));
 t = make_tree(t, btree_insert(t, 5));
 t = make_tree(t, btree_insert(t, 6));
 t = make_tree(t, btree_insert(t, 7));
-t = make_tree(t, btree_insert(t, 8));
+
-t = make_tree(t, btree_insert(t, 5));
+enable_logging = true;
-t = make_tree(t, btree_insert(t, 5));
+t = make_tree(t, btree_delete(t, 5));
-// console.log(t);
+enable_logging = false;
-//enable_logging = false;
+
 display_tree(t);

2022/03/algorithms/distance.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const fs = require('fs');
+
+process.stdin.resume();
+process.stdin.setEncoding('utf-8');
+
+let inputString = '';
+let currentLine = 0;
+
+process.stdin.on('data', function(inputStdin) {
+    inputString += inputStdin;
+});
+
+process.stdin.on('end', function() {
+    inputString = inputString.split('\n');
+
+    main();
+});
+
+process.on('SIGINT', function() {
+    inputString = inputString.split('\n');
+
+    main();
+    process.exit(0);
+});
+
+function readLine() {
+    return inputString[currentLine++];
+}
+
+/*
+ * Complete the 'appendAndDelete' function below.
+ *
+ * The function is expected to return a STRING.
+ * The function accepts following parameters:
+ *  1. STRING s
+ *  2. STRING t
+ *  3. INTEGER k
+ */
+
+function appendAndDelete(s, t, k) {
+    s = s.trim();
+    t = t.trim();
+    let n = s.length;
+    let m = t.length;
+
+    // console.log(`n: ${n}, m: ${m}`);
+
+    let a = new Array(n+1);
+    for (let i = 0; i <= n; i++) {
+        a[i] = new Array(m+1);
+    }
+
+    for (let i = 0; i <= m; i++) {
+        a[0][i] = i;
+    }
+
+    for (let i = 0; i <= n; i++) {
+        a[i][0] = i;
+    }
+
+    for (let i = 1; i <= n; i++) {
+        for (let j = 1; j <= m; j++) {
+            // console.log(`I: ${i}, J: ${j}, Sc: ${s[i-1]}, Tc: ${t[j-1]}`);
+            if (s[i-1] === t[j-1]) {
+                a[i][j] = a[i-1][j-1];
+            } else {
+                a[i][j] = Math.min(a[i-1][j]+1, a[i][j-1]+1);
+            }
+        }
+    }
+
+    // console.log('Array', a);
+
+    console.log(`Min operations: ${a[n][m]}`);
+
+    let res = a[n][m] <= k ? 'Yes': 'No';
+    // console.log(`Res: ${res}`);
+    return res;
+
+}
+
+function main() {
+    const ws = fs.createWriteStream(process.env.OUTPUT_PATH);
+
+    const s = readLine();
+
+    const t = readLine();
+
+    const k = parseInt(readLine().trim(), 10);
+
+    const result = appendAndDelete(s, t, k);
+
+    ws.write(result + '\n');
+
+    ws.end();
+}

2022/03/algorithms/factorial.js

@@ -0,0 +1,106 @@
+"use strict";
+
+function mul2(v) {
+	let res = [];
+	let shift = 0;
+	let t;
+	for (let i = v.length - 1; i >= 0; i--) {
+		t = v[i]*2 + shift;
+		shift = t >= 10 ? 1 : 0;
+		res.unshift(t % 10);
+	}
+
+	if (shift > 0) {
+		res.unshift(1);
+	}
+
+	return res;
+}
+
+function div2(v) {
+	let res = [];
+	let s = 0, div;
+	let leading = false;
+	for (let i = 0; i < v.length; i++) {
+		s = s*10 + v[i];
+		div = s >> 1;
+		s = s - 2*div;
+		if (!leading && div > 0) {
+			leading = true;
+		}
+		if (leading || Math.abs(div) > 1e-6) {
+			res.push(div);
+		} 
+	}
+
+	if (!res.length) {
+		res.push(0);
+	}
+
+	return res;
+}
+
+function odd(a) {
+	return a.length > 0 ? a[a.length-1] % 2 === 1: false;
+}
+
+function zero(a) {
+	return !a.length || (a.length == 1 && a[0] === 0);
+}
+
+function sum(a, b) {
+	let x = [...a];
+	let y = [...b];
+	let shift = 0;
+	let res   = []
+	let e1, e2, e3;
+	while (x.length || y.length) {
+		e1 = x.length ? x.pop() : 0;
+		e2 = y.length ? y.pop() : 0;
+		e3 = e1+e2+shift;
+		res.unshift(e3 % 10);
+		shift = e3 >= 10 ? 1 : 0;
+	}
+
+	if (shift) {
+		res.unshift(1);
+	}
+
+	return res;
+}
+
+function mul(a, b) {
+	let x = [...a];
+	let y = [...b];
+	let x2;
+	let y2;
+
+	let s = [0];
+
+	while (!zero(x)) {
+		x2 = div2(x);
+		y2 = mul2(y);
+		if (odd(x)) {
+			s = sum(s, y);
+		}
+		x = x2;
+		y = y2;
+	}
+
+	return s;
+}
+
+function factorial(x) {
+	let c = [ 0 ];
+	let m =  [1];
+	let mp = [1];
+	for (let i = 0; i < x; i++) {
+		c = sum(c, [1]);
+		m = mul(mp, c);
+		mp = m;
+	}
+
+	return m;
+}
+
+console.log(factorial(7).map((el) => '' + el).join(''));

2022/03/algorithms/liss.js

@@ -0,0 +1,22 @@
+
+
+function liss(arr) {
+	console.log('Array', arr);
+	let n = arr.length;
+	let liss = new Array(n);
+	liss[n-1] = 1;
+	let cliss;
+	for (let i = n-2; i >= 0; i--) {
+		cliss = 1;
+		for (let j = i+1; j < n; j++) {
+			if (arr[i] < arr[j]) {
+				cliss = Math.max(cliss, 1+liss[j]);
+			}
+		}
+		liss[i] = cliss;
+		console.log(`LISS(${i}) == ${liss[i]}`);
+	}
+	return cliss[0];
+}
+
+console.log(`LISS ${liss([1,2,4,3])}`);

2022/03/algorithms/maxflow_push_relabel.js

@@ -0,0 +1,268 @@
+"use strict";
+
+const fs = require('fs');
+const {EOL} = require('os');
+const eps = 1e-6;
+
+function chooseActiveNodeForRelabel(c, e, h) {
+	let n = h.length;
+	for (let i = 0; i < n; i++) {
+		if (e[i] <= 0) {
+			continue;
+		}
+
+		for (let j = 0; j < n; j++) {
+			if (c[i][j] <= 0) {
+				// in edge E_f
+				continue;
+			}
+
+			if (h[i] > h[j]) {
+				break;
+			}
+		}
+
+		return i;
+	}
+
+	return -1;
+}
+
+function chooseActiveNodeForPush(c, e, h) {
+	let n = h.length;
+	for (let i = 0; i < n; i++) { // what about replacing it with priority queues
+		if (e[i] <= 0) {
+			continue;
+		}
+
+		// we are looking for nodes if excess
+
+		for (let j = 0; j < n; j++) { // what about replacing it with priority queues
+			if (c[i][j] <= 0 || h[i] != h[j] + 1) {
+				continue;
+			}
+
+			// c[i][j] > 0 && h[i] == h[j] + 1
+			return [i, j];
+		}
+	}
+
+	return [-1, -1];
+}
+
+function findMaximumFlow(graph) {
+	let nodes = [];
+	let m = {};
+	for (let el of graph.nodes) {
+		nodes.push(el);
+	}
+
+	for (let i = 0; i < nodes.length; i++) {
+		m[nodes[i]] = i;
+	}
+
+	const n = nodes.length;
+	let c = new Array(n);
+	let oc = new Array(n);
+	let f = new Array(n);
+	let h = new Array(n);
+	let e = new Array(n); // excess flow
+	for (let i = 0; i < n; i++) {
+		c[i]  = new Array(n); // residual capacity
+		oc[i] = new Array(n); // residual capacity
+		f[i]  = new Array(n); // flow
+		h[i]  = 0; // node height
+		e[i]  = 0; // node flow excess
+	}
+
+	h[m[graph.source]] = n;
+
+	for (let i = 0; i < n; i++) {
+		for (let j = 0; j < n; j++) {
+			f[i][j]  = 0;
+			c[i][j]  = 0;
+			oc[i][j] = 0;
+		}
+	}
+
+	// init capacity
+
+	for (let v in graph.edges) {
+		for (let {node, weight} of graph.edges[v]) {
+			c[m[v]][m[node]]  = weight;
+			oc[m[v]][m[node]] = weight;
+		}
+	}
+
+	for (let {node, weight} of graph.edges[graph.source]) {
+		f[m[graph.source]][m[node]] = weight;
+		e[m[node]] = weight;
+		e[m[graph.source]] -= weight;
+	}
+
+	console.log('Capacity', c);
+	console.log('Flow', f);
+	console.log('Height', h);
+	console.log('Excess', e);
+
+	// try push
+	// if not relabel
+	// and repeat till it's possible
+
+	// quite naive way to choose active node for push
+	do {
+		// push
+		let [ci, cj] = chooseActiveNodeForPush(c, e, h);
+		if (ci >= 0 && cj >= 0) {
+			console.log(`Pushing (${ci},${cj})`);
+			let flow = Math.min(e[ci], c[ci][cj]);
+			if (oc[ci][cj] > 0) { // if ci, cj exists in e edges
+				f[ci][cj] += flow;
+			} else {
+				f[cj][ci] -= flow;
+			}
+
+			e[ci] -= flow;
+			e[cj] += flow;
+		} else {
+			// relabel
+			let ri = chooseActiveNodeForRelabel(c, e, h);
+			if (ri >= 0) {
+				console.log(`Relabeling (${ri})`);
+				let hMax = -Infinity;
+				for (let i = 0; i < n; i++) {
+					if (c[ri][i] <= 0) {
+						continue;
+					}
+					hMax = Math.max(hMax, h[i]);
+				}
+				if (hMax <= 0) {
+					continue;
+				}
+				h[ri] = hMax + 1;
+				console.log(`Setting height ${h[ri]} for ${ri}`);
+			} else {
+				console.log('Maximal flow...');
+				break; // we have maximal flow
+			}
+		}
+	} while (true);
+
+	let flow = 0;
+	for (let j = 0; j < n; j++) {
+		flow += f[m[graph.source]][j];
+	}
+	return flow;
+}
+
+function sourceCmdLine(ctx, cmdLine) {
+	ctx.source = cmdLine.slice(
+		'source'.length,
+		cmdLine.indexOf(';')
+	).trim();
+}
+
+function targetCmdLine(ctx, cmdLine) {
+	ctx.target = cmdLine.slice(
+		'target'.length,
+		cmdLine.indexOf(';')
+	).trim();
+}
+
+function edgeCmdLine(ctx, cmdLine) {
+	let edgeLine = cmdLine.slice(
+		'edge'.length,
+		cmdLine.indexOf(';')
+	).trim();
+	console.log(`Edge line ${edgeLine}`);
+
+	const matches = edgeLine.match(/^([a-zA-Z]*) -> ([a-zA-Z]*): ([0-9.]*)$/);
+	// console.log('Matches', matches);
+	const v = matches[1];
+	const z = matches[2];
+	const weight = Number.parseFloat(matches[3]);
+
+	console.log(`Parsed ${v} ->  ${z} : ${weight}`);
+
+	ctx.nodes.add(v);
+	ctx.nodes.add(z);
+	let targetEdges = ctx.edges[v] || [];
+	targetEdges.push({node: z, weight});
+	ctx.edges[v] = targetEdges;
+
+}
+
+function processCmdLine(ctx, cmdLine) {
+	console.log(`Processing command line ${cmdLine}`);
+	if (cmdLine.startsWith('source')) {
+		sourceCmdLine(ctx, cmdLine);
+	} else if (cmdLine.startsWith('target')) {
+		targetCmdLine(ctx, cmdLine);
+	} else if (cmdLine.startsWith('edge')) {
+		edgeCmdLine(ctx, cmdLine);
+	}
+}
+
+console.log(`Process argv: ${process.argv}`);
+
+const inputPath  = process.argv.length > 2 ? process.argv[2] : '-';
+const outputPath = process.argv.length > 3 ? process.argv[3] : '-';
+
+console.log(`Input path ${inputPath}, output path: ${outputPath}`);
+
+const inputStream = inputPath === '-' 
+	? process.stdin
+	: fs.createReadStream(inputPath);
+
+// const outputStream = outputPath === '-' 
+// 	? process.stdout
+//	: fs.createWriteStream(outputStream);
+
+let inputBuffer = "";
+let ctx = {
+	source: '',
+	target: '',
+	edges: {},
+	nodes: new Set()
+};
+
+function processChunk(chunk) {
+	inputBuffer += chunk;
+	console.log(`Chunk: ${chunk}`);
+	let eolIdx;
+	do {
+		eolIdx = inputBuffer.indexOf(EOL);
+		if (eolIdx < 0 && !chunk) {
+			eolIdx = inputBuffer.length;
+		}
+
+		let cmdLine = null;
+		if (eolIdx >= 0) {
+			console.log(`We got new line ${eolIdx}`);
+			cmdLine = inputBuffer.slice(0, eolIdx);
+			processCmdLine(ctx, cmdLine);
+			inputBuffer = inputBuffer.slice(eolIdx+EOL.length);
+		}
+	} while (eolIdx >= 0 && inputBuffer.length);
+}
+
+inputStream.on('data', (chunk) => {
+	processChunk(chunk);
+});
+
+inputStream.on('end', (chunk) => {
+	console.log(`end chunk ${chunk}`);
+	processChunk(chunk);
+	console.log('Got following graph', ctx);
+
+	for (let v in ctx.edges) {
+		for (let {node, weight} of ctx.edges[v]) {
+			console.log(`${v} ${node} : ${weight}`);
+		}
+	}
+
+	let mflow = findMaximumFlow(ctx);
+
+	console.log(`Maximum flow is ${mflow}`);
+
+});

2022/03/algorithms/non_divisible_subset.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const fs = require('fs');
+
+process.stdin.resume();
+process.stdin.setEncoding('utf-8');
+
+let inputString = '';
+let currentLine = 0;
+
+process.stdin.on('data', function(inputStdin) {
+    inputString += inputStdin;
+});
+
+process.stdin.on('end', function() {
+    inputString = inputString.split('\n');
+
+    main();
+});
+
+process.on('SIGINT', function() {
+    inputString = inputString.split('\n');
+
+    main();
+    process.exit(0);
+});
+
+function readLine() {
+    return inputString[currentLine++];
+}
+
+/*
+ * Complete the 'nonDivisibleSubset' function below.
+ *
+ * The function is expected to return an INTEGER.
+ * The function accepts following parameters:
+ *  1. INTEGER k
+ *  2. INTEGER_ARRAY s
+ */
+
+function nonDivisibleSubset(k, s) {
+    let counts = new Array(k);
+    for (let i = 0; i < k; i++) {
+        counts[i] = 0;
+    }
+
+    for (let el of s) {
+        counts[el % k]++;
+    }
+
+    let count = Math.min(1, counts[0]);
+    for (let i = 1; i <= k >> 1; i++) {
+        let j = k - i;
+        if (i !== j) {
+            count += Math.max(counts[i], counts[j]);
+        } else {
+            count += Math.min(1, counts[i]);
+        }
+    }
+    return count;
+}
+
+function main() {
+    const ws = fs.createWriteStream(process.env.OUTPUT_PATH);
+
+    const firstMultipleInput = readLine().replace(/\s+$/g, '').split(' ');
+
+    const n = parseInt(firstMultipleInput[0], 10);
+
+    const k = parseInt(firstMultipleInput[1], 10);
+
+    const s = readLine().replace(/\s+$/g, '').split(' ').map(sTemp => parseInt(sTemp, 10));
+
+    const result = nonDivisibleSubset(k, s);
+
+    console.log(`Result ${result}`);
+
+    ws.write(result + '\n');
+
+    ws.end();
+}

2022/03/algorithms/non_divisible_subset_naive.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const fs = require('fs');
+
+process.stdin.resume();
+process.stdin.setEncoding('utf-8');
+
+let inputString = '';
+let currentLine = 0;
+let sigintCalled = 0;
+
+process.stdin.on('data', function(inputStdin) {
+    inputString += inputStdin;
+});
+
+process.stdin.on('end', function() {
+    inputString = inputString.split('\n');
+
+    main();
+});
+
+process.on('SIGINT', function() {
+    ++sigintCalled;
+        console.log(`SIGINT ${sigintCalled}`);
+    if (sigintCalled >= 2) {
+        process.exit(1);
+        return;
+    }
+
+    inputString = inputString.split('\n');
+
+    main();
+    process.exit(0);
+});
+
+function readLine() {
+    return inputString[currentLine++];
+}
+
+/*
+ * Complete the 'nonDivisibleSubset' function below.
+ *
+ * The function is expected to return an INTEGER.
+ * The function accepts following parameters:
+ *  1. INTEGER k
+ *  2. INTEGER_ARRAY s
+ */
+
+function nonDivisibleSubset(k, s) {
+    if (sigintCalled >= 2) {
+        process.exit(1);
+        return null;
+    }
+    
+    console.log('k', k, 's', s);
+
+    if (s.length <= 1) {
+        return s.length;
+    }
+
+    let el = s[0];
+    // with
+    let msize1 = nonDivisibleSubset(
+        k,
+        s.slice(1).filter((a) => {
+            return (a + el) % k !== 0
+        })
+    ) + 1;
+    // or without
+
+    let msize2 = nonDivisibleSubset(k, s.slice(1));
+    return Math.max(msize1, msize2);
+}
+
+function main() {
+    const ws = fs.createWriteStream(process.env.OUTPUT_PATH);
+
+    const firstMultipleInput = readLine().replace(/\s+$/g, '').split(' ');
+
+    const n = parseInt(firstMultipleInput[0], 10);
+
+    const k = parseInt(firstMultipleInput[1], 10);
+
+    const s = readLine().replace(/\s+$/g, '').split(' ').map(sTemp => parseInt(sTemp, 10));
+
+    const result = nonDivisibleSubset(k, s);
+
+    console.log(`Result ${result}`);
+
+    ws.write(result + '\n');
+
+    ws.end();
+}

2022/03/algorithms/repeated_string.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const fs = require('fs');
+
+process.stdin.resume();
+process.stdin.setEncoding('utf-8');
+
+let inputString = '';
+let currentLine = 0;
+
+process.stdin.on('data', function(inputStdin) {
+    console.log(`Data: ${inputStdin}`);
+    inputString += inputStdin;
+});
+
+process.stdin.on('end', function() {
+    console.log(`End`);
+    inputString = inputString.split('\r\n');
+
+    main();
+});
+
+process.on('SIGINT', function() {
+    console.log('SIGINT');
+    inputString = inputString.split('\r\n');
+
+    main();
+    process.exit(0);
+});
+
+function readLine() {
+    return inputString[currentLine++];
+}
+
+/*
+ * Complete the 'repeatedString' function below.
+ *
+ * The function is expected to return a LONG_INTEGER.
+ * The function accepts following parameters:
+ *  1. STRING s
+ *  2. LONG_INTEGER n
+ */
+
+function repeatedString(s, n) {
+    let sl = s.length;
+    console.log(`S: ${sl}, n: ${n}`);
+    let counts = new Array(sl+1);
+    counts[0] = 0;
+    for (let i = 1; i < counts.length; i++) {
+        counts[i] = s[i-1] === 'a' ? counts[i-1] + 1 : counts[i-1];
+    }
+
+    console.log('Counts', counts);
+    
+    let c = Math.floor(n / sl);
+    let r = n % sl;
+    return counts[sl] * c + counts[r];
+}
+
+function main() {
+    const ws = fs.createWriteStream(process.env.OUTPUT_PATH);
+
+    const s = readLine();
+
+    const n = parseInt(readLine().trim(), 10);
+
+    const result = repeatedString(s, n);
+
+    console.log(`Result ${result}`);
+
+    ws.write(result + '\n');
+
+    ws.end();
+}

2022/03/algorithms/time_conversion.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const fs = require('fs');
+
+process.stdin.resume();
+process.stdin.setEncoding('utf-8');
+
+let inputString = '';
+let currentLine = 0;
+
+process.stdin.on('data', function(inputStdin) {
+    inputString += inputStdin;
+});
+
+process.stdin.on('end', function() {
+    inputString = inputString.split('\n');
+
+    main();
+});
+
+process.on('SIGINT', function() {
+    inputString = inputString.split('\n');
+
+    main();
+    process.exit(0);
+});
+
+function readLine() {
+    return inputString[currentLine++];
+}
+
+/*
+ * Complete the 'timeConversion' function below.
+ *
+ * The function is expected to return a STRING.
+ * The function accepts STRING s as parameter.
+ */
+
+function timeConversion(s) {
+    s = s.trim();
+    let shift = 0;
+    if (s.endsWith('PM')) {
+        shift += 12;
+    }
+    s = s.substring(0, s.length - 2);
+    let splits = s.split(":");
+    let hour = Number.parseInt(splits[0]) % 12 + shift;
+    let minute = Number.parseInt(splits[1]);
+    let seconds = Number.parseInt(splits[2]);
+    return ("" + hour).padStart(2, "0")
+        + ":" + ("" + minute).padStart(2, "0")
+        + ":" + ("" + seconds).padStart(2, "0");
+}
+
+function main() {
+    const ws = fs.createWriteStream(process.env.OUTPUT_PATH);
+
+    const s = readLine();
+
+    const result = timeConversion(s);
+
+    ws.write(result + '\n');
+    ws.end();
+    ws.close();
+}