diff --git a/2022/03/algorithms/append_delete_bfs.js b/2022/03/algorithms/append_delete_bfs.js new file mode 100644 index 0000000..be9add7 --- /dev/null +++ b/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(); +} diff --git a/2022/03/algorithms/append_delete_final.js b/2022/03/algorithms/append_delete_final.js new file mode 100644 index 0000000..3b012fa --- /dev/null +++ b/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(); +} diff --git a/2022/03/algorithms/append_delete_opt.js b/2022/03/algorithms/append_delete_opt.js new file mode 100644 index 0000000..2055089 --- /dev/null +++ b/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(); +} diff --git a/2022/03/algorithms/btree.js b/2022/03/algorithms/btree.js index 8dd7016..d76e17d 100644 --- a/2022/03/algorithms/btree.js +++ b/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)); -t = make_tree(t, btree_insert(t, 5)); -// console.log(t); -//enable_logging = false; + +enable_logging = true; +t = make_tree(t, btree_delete(t, 5)); +enable_logging = false; + display_tree(t); \ No newline at end of file diff --git a/2022/03/algorithms/distance.js b/2022/03/algorithms/distance.js new file mode 100644 index 0000000..b08653e --- /dev/null +++ b/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(); +} diff --git a/2022/03/algorithms/factorial.js b/2022/03/algorithms/factorial.js new file mode 100644 index 0000000..dbd0040 --- /dev/null +++ b/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('')); \ No newline at end of file diff --git a/2022/03/algorithms/liss.js b/2022/03/algorithms/liss.js new file mode 100644 index 0000000..556e94b --- /dev/null +++ b/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])}`); \ No newline at end of file diff --git a/2022/03/algorithms/maxflow1.js b/2022/03/algorithms/maxflow_edmunds_karps.js similarity index 100% rename from 2022/03/algorithms/maxflow1.js rename to 2022/03/algorithms/maxflow_edmunds_karps.js diff --git a/2022/03/algorithms/maxflow_push_relabel.js b/2022/03/algorithms/maxflow_push_relabel.js new file mode 100644 index 0000000..f1cc12e --- /dev/null +++ b/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}`); + +}); diff --git a/2022/03/algorithms/non_divisible_subset.js b/2022/03/algorithms/non_divisible_subset.js new file mode 100644 index 0000000..3bf6d1e --- /dev/null +++ b/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(); +} diff --git a/2022/03/algorithms/non_divisible_subset_naive.js b/2022/03/algorithms/non_divisible_subset_naive.js new file mode 100644 index 0000000..26f5da2 --- /dev/null +++ b/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(); +} diff --git a/2022/03/algorithms/repeated_string.js b/2022/03/algorithms/repeated_string.js new file mode 100644 index 0000000..88b4e3c --- /dev/null +++ b/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(); +} diff --git a/2022/03/algorithms/time_conversion.js b/2022/03/algorithms/time_conversion.js new file mode 100644 index 0000000..18d0abd --- /dev/null +++ b/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(); +}