Made tasks

JavaScript/8-timerMemoize.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const argKey = x => (x.toString() + ':' + typeof(x));
+const generateKey = arg => arg.map(argKey).join('|');
+
+const timerMemoize = (fn, msec) => {
+  const cache = new Map();
+  return (...args) => {
+    const key = generateKey(args);
+    const timeout = setTimeout(() => cache.delete(key), msec);
+    if (cache.has(key)) {
+      const value = cache.get(key);
+      console.log('From cache: ', value.res);
+      clearTimeout(value.timeout);
+      value.timeout = timeout;
+      return value.res;
+    }
+    const res = fn(...args);
+    cache.set(key, { timeout, res });
+    console.log('Calculated: ', res);
+    return res;
+  };
+};
+
+const sum = (a, b) => a + b;
+const f1 = timerMemoize(sum, 10000);
+f1(1, 2);
+f1(1, 2);
+f1(1, 2);
+f1(2, 4);
+f1(2, 4);
+setTimeout(() => f1(2, 4), 9000);
+setTimeout(() => f1(2, 4), 12000);
+setTimeout(() => f1(2, 4), 22500);
+setTimeout(() => f1(2, 4), 23000);

JavaScript/9-countMemoize.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const argKey = x => (x.toString() + ':' + typeof(x));
+const generateKey = arg => arg.map(argKey).join('|');
+
+const countMemoize = (fn, max) => {
+  const cache = new Map();
+  return (...args) => {
+    const key = generateKey(args);
+    if (cache.has(key)) {
+      const value = cache.get(key);
+      console.log('from cache:', value.res);
+      value.count += 1;
+      return value.res;
+    }
+    const res = fn(...args);
+    console.log('Calculated:', res);
+    if (cache.size > max) {
+      let [deleted, { count: num }] = cache.entries().next().value;
+      cache.forEach((value, keys) => {
+        const count = value.count;
+        if (num >= count) {
+          num = count;
+          deleted = keys;
+        }
+      });
+      console.log('deleted: ', deleted);
+      cache.delete(deleted);
+    }
+    cache.set(key, { res, count: 1 });
+    return res;
+  };
+};
+
+const sum = (a, b) => a + b;
+const f1 = countMemoize(sum, 3);
+f1(1, 2);
+f1(1, 2);
+f1(1, 2);
+f1(2, 4);
+f1(2, 4);
+f1(3, 4);
+f1(4, 4);
+f1(4, 4);
+f1(3, 4);
+f1(4, 4);
+f1(4, 4);
+f1(5, 4);
+f1(5, 4);

JavaScript/a-sizeMemoize.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const argKey = x => (x.toString() + ':' + typeof(x));
+const generateKey = arg => arg.map(argKey).join('|');
+
+const sizeMemoize = (fn, maxSize) => {
+  const cache = new Map();
+  const sizeToBytes = (size) => {
+    if(/[TGMKBtgmkb]/.test(size)) {
+      const k =  parseFloat(size.slice(0, size.length - 1));
+      const char = size.slice(size.length - 1);
+      const tableOfSize = {
+        T: Math.pow(2, 40),
+        G: Math.pow(2, 30),
+        M: Math.pow(2, 20),
+        K: Math.pow(2, 10),
+        B: 1,
+      };
+      return tableOfSize[char.toUpperCase()] * k;
+    }
+    else return parseFloat(size);
+  };
+  const getSize = function(arg) {
+    if (!arg) return 0;
+    let countOfObj = 0;
+    const getSizeTable = {
+      number: 8,
+      boolean: 4,
+      string: arg.length * 2,
+    };
+    if (typeof(arg) === 'object') {
+      for (const value of arg.values()) {
+        ({ res: arg } = value);
+        countOfObj += (getSizeTable[typeof(arg)] ? getSizeTable[typeof(arg)] : getSize(arg));
+      }
+      return countOfObj;
+    } else {
+      const countOfArg = getSizeTable[typeof(arg)]; 
+      return countOfArg;
+    }
+  };
+  return (...args) => {
+    const key = generateKey(args);
+    if (cache.has(key)) {
+      const value = cache.get(key);
+      console.log('from cache:', value.res);
+      value.count += 1;
+      return value.res;
+    }
+    const res = fn(...args);
+    const inBytes = sizeToBytes(maxSize);
+    if (getSize(res) > inBytes) {
+      console.log('Size of result more than can hold cache!');
+      console.log('Calculated:', res);
+      return res;
+    }
+    while (getSize(cache) + getSize(res) > inBytes) {
+      let  [deleted, { count: num }] = cache.entries().next().value;
+      cache.forEach((value, key) => {
+        const count = value.count;
+        if (num >= count) {
+          num = count;
+          deleted = key;
+        }
+      });
+      console.log('deleted:', deleted);
+      cache.delete(deleted);
+    }
+    console.log('Calculated:', res);
+    cache.set(key, { res, count: 1 });
+    return res;
+  };
+};
+const sum = (a, b) => a + b;
+const f1 = sizeMemoize(sum, '20');
+f1('s', 'qsssss');
+f1(1, 2);
+f1(1, 2);
+f1(true, false);
+f1(2, 4);
+f1(2, 4);
+f1(2, 4);
+f1(3, 4);
+f1('22', 4);
+f1('qqqqq', 'qqqqqqq');
+f1('qqqqq', 'qqqqq');
+f1(4, 4);
+f1('q', 4);
+f1(5, 4);
+f1(5, 4);
+
+
+

JavaScript/b-syncAsyncMemoize.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const argKeySync = x => (x.toString() + ':' + typeof(x));
+const generateKeySync = arg => arg.map(argKeySync).join('|').concat('(Sync)');
+const generateKeyAsync = arg => arg.slice().shift().concat('(Async)');
+const fs = require('fs');
+
+const syncAsyncMemoize = function(fn) {
+  const cache = new Map();
+  return (...args) => {
+    if (typeof(args[args.length - 1]) === 'function') {
+      const callback = args.pop();
+      const key = generateKeyAsync(args);
+      if (cache.has(key)) {
+        const value = cache.get(key);
+        console.log('Async cache');
+        callback(value.err, value.data);
+        return;
+      }
+      fn(...args, (err, data) => {
+        console.log('Async calculated');
+        cache.set(key, { err, data });
+        callback(err, data);
+      });
+    } else {
+      const key = generateKeySync(args);
+      if (cache.has(key)) {
+        const value = cache.get(key);
+        console.log('from cache:', value);
+        return value;
+      }
+      const res = fn(...args);
+      cache.set(key, res);
+      console.log('Calculated:', res);
+      return res;
+    }
+  };
+};
+const sum = (a, b) => a + b;
+const f1 = syncAsyncMemoize(sum);
+f1(1, 2);
+f1(1, 2);
+f1(2, 2);
+f1(2, 2);
+f1(2, 2);
+
+const readfile = syncAsyncMemoize(fs.readFile);
+readfile('sizeMemoize.js', 'utf8', (err, data) => {
+  console.log(data.length);
+  readfile('sizeMemoize.js', 'utf8', (err, data) => {
+    console.log(data.length);
+  });
+});