design patterns and paradigms

Author: Vitalii Telychko

codewars/binary_addition.js

@@ -0,0 +1,5 @@
+function addBinary(a,b) {
+  return (a + b).toString(2).toString();
+}
+
+addBinary(4, 5);

codewars/junior_level/catching_car_mileage_numbers.js renamed to codewars/catching_car_mileage_numbers.js

@@ -0,0 +1,7 @@
+// function findMissingLetter(array) {
+//   let i, string = array.join(''), size = string.length;
+//   for (i = 0; i < size; i += 1) {
+//     if(string.charCodeAt(i) !== string.charCodeAt(0) + i) return String.fromCharCode(string.charCodeAt(i) - 1);
+//   }
+//   return '';
+// }

codewars/junior_level/directions_reduction.js renamed to codewars/directions_reduction.js

@@ -0,0 +1,5 @@
+function largestDifference(data) {
+  
+}
+
+largestDifference([1, 2, 3]);

codewars/senior_level/escape_the_mines.js renamed to codewars/escape_the_mines.js

@@ -0,0 +1,13 @@
+function nextBigger(n){
+  var str = n.toString().split(''), size = str.length, temp;
+  for(var i = 0; i < size; i += 1) {
+    if(str[i + 1] > str[i]) {
+      temp = str[i];
+      str[i] = str[i + 1];
+      str[i + 1] = temp;
+    }
+  }
+  return +str.join('');
+}
+
+console.log(nextBigger(2017));

codewars/find_the_missing_letter.js

@@ -0,0 +1,23 @@
+var sample_data = [0, 1, 100, 99, 0, 10, 90, 30, 55, 33];
+
+function pairsWithSum(sum, data) {
+  let pairs = [], i = 0, size = data.length, j = size - 1, a, b;
+  data.sort((a, b) => a - b);
+  while (i < j && j >= 0) {
+    a = data[i];
+    b = data[j];
+    if (a + b === sum) {
+      pairs.push([a, b]);
+      while (i < size && data[i] === a) {
+        i += 1;
+      }
+      while (j >= 0 && data[j] === b) {
+        j -= 1;
+      }
+    } else if (a + b < sum) while(i < size && data[i += 1] === a);
+    else while(j >= 0 && data[j -= 1] === b);
+  }
+  return pairs;
+}
+
+pairsWithSum(100, sample_data);

codewars/junior_level/find_the_parity_outlier.js renamed to codewars/find_the_parity_outlier.js

@@ -0,0 +1,2 @@
+weirdReverse=a=>a.sort((a, b)=>a-b); // a.sort(_=>1);
+weirdReverse([5,4,3,2,1]);

codewars/senior_level/going_to_zero_or_infinity.js renamed to codewars/going_to_zero_or_infinity.js

@@ -1,3 +1,7 @@
+// Usually the controller instantiates the view and the model in the constructor or, in certain implementations, are injected by the main application class via dependency injection.
+// The relation between a controller and the views could be one to many, so a controller could handle multiple views: the same relationship is valid for the models as well.
+// When we want to scale up this architecture for large projects usually we try to split up these relationships in order to have almost a 1 to 1 relation between these three objects so we can reuse components that are self-contained and architected in the same way the entire application works, like a Russian doll.
+
 // VIEW
 var view = {
     showNumber: function (n) {

codewars/junior_level/growth_of_population.js renamed to codewars/growth_of_population.js

@@ -0,0 +1,82 @@
+// The main differences between MVP and MVC could be summarized in the following list:
+// Having a presenter instead of a controller, we will see in a moment which benefits come in with a presenter.
+// The relation between a view and a presenter is not 1 to many like in MVC but is always 1 to 1.
+// The best MVP implementation for having reusable components is when we design our views as passive views because swapping them becomes easier as long the contract between the presenter and the view is respected.
+
+
+// MODEL
+function TaskModel(_text){
+  var ID = (new Date()).getTime(), Text = _text;
+  this.getID = function(){
+    return ID;
+  };
+  this.getText = function(){
+    return Text;
+  };
+  this.setText = function(value){
+    Text = value;
+  }
+}
+
+// VIEW
+function TaskView(){
+  var html;
+  function init(){
+    html = $("<input type='checkbox'/><label></label></li>");
+  }
+
+  var public = {
+    getHtml: function(){
+      return html;
+    },
+    setModel: function(model){
+      html.find("input").attr("id", model.getID());
+      html.find("label").attr("for", model.getID());
+      html.find("label").html(model.getText());
+    },
+    addCheckedHandler: function(handler){
+      html.find("input").click(handler);
+    },
+    remove: function(){
+      html.remove();
+    }
+  };
+
+  init();
+  return public;
+}
+
+// PRESENTER
+function TaskPresenter(_view){
+  var view, model;
+
+  function init(){
+    view = _view;
+    view.addCheckedHandler(function(){
+      view.remove();
+    });
+  }
+
+  var public = {
+    getView: function(){
+      return view;
+    },
+    setModel: function(_model){
+      model = _model;
+      view.setModel(model);
+    }
+  };
+
+  init();
+  return public;
+}
+
+
+// INIT
+var model = new TaskModel("Hello world!");
+var task = new TaskPresenter(new TaskView());
+
+task.setModel(model);
+
+$("body").append(task.getView().getHtml());
+

codewars/junior_level/jaden_casing_strings.js renamed to codewars/jaden_casing_strings.js

@@ -0,0 +1,45 @@
+// Imperative Way
+
+// class Calculator {
+//   sum(a, b) {
+//     return a + b;
+//   }
+// }
+//
+// class Receipt {
+//   constructor(calculator) {
+//     this.calc = calculator;
+//   }
+//   print(itemA, itemB) {
+//     const total = this.calc.sum(itemA, itemB);
+//     console.log(`total receipt $ ${total}`);
+//   }
+// }
+//
+// const pizza = 6.00, beer = 5.00,
+//       calc = new Calculator(),
+//       receipt = new Receipt(calc);
+// receipt.print(pizza, beer);
+
+// Reactive Way
+
+// class Calculator {
+//   constructor(itemA, itemB) {
+//     const obs = Rx.Observable.of(itemA, itemB);
+//     const sum = obs.reduce((acc, item) => acc + item);
+//     return {
+//       observable: sum
+//     }
+//   }
+// }
+//
+// class Receipt {
+//   constructor(observable$) {
+//     observable$.subscribe(value => console.log(`total receipt $ ${value}`));
+//   }
+// }
+//
+// const pizza = 6.00, beer = 5.00,
+//       calc = new Calculator(pizza, beer),
+//       receipt = new Receipt(calc.observable);
+// receipt.print(pizza, beer);

codewars/junior_level/binary_addition.js

@@ -0,0 +1,55 @@
+// IoC Container Example
+export default class Container {
+  constructor() {
+    this._services = new Map();
+    this._singletons = new Map();
+  }
+  register(name, definition, dependencies) {
+    this._services.set(name, {definition: definition, dependencies: dependencies})
+  }
+
+  singleton(name, definition, dependencies) {
+    this._services.set(name, {definition: definition, dependencies: dependencies, singleton:true})
+  }
+
+  get(name) {
+    const c = this._services.get(name);
+
+    if(this._isClass(c.definition)) {
+
+      if(c.singleton) {
+        const singletonInstance = this._singletons.get(name);
+        if(singletonInstance) {
+          return singletonInstance
+        } else {
+          const newSingletonInstance = this._createInstance(c);
+          this._singletons.set(name, newSingletonInstance);
+          return newSingletonInstance;
+        }
+      }
+
+      return this._createInstance(c);
+
+    } else {
+      return c.definition;
+    }
+  }
+
+  _getResolvedDependencies(service) {
+    let classDependencies = [];
+    if(service.dependencies) {
+      classDependencies = service.dependencies.map((dep) => {
+        return this.get(dep)
+      })
+    }
+    return classDependencies;
+  }
+
+  _createInstance(service) {
+    return new service.definition(...this._getResolvedDependencies(service))
+  }
+
+  _isClass(definition) {
+    return typeof definition === 'function'
+  }
+}

codewars/junior_level/find_the_missing_letter.js

@@ -8,6 +8,8 @@
 </head>
 <body>
 
-<script src="sorting_algorithms/quicksort.js"></script>
+<script src="https://unpkg.com/react@16/umd/react.development.js" crossorigin></script>
+<script src="https://unpkg.com/react-dom@16/umd/react-dom.development.js" crossorigin></script>
+<script src="design_patterns/architectural/MVP/MVP.js"></script>
 </body>
 </html>

codewars/junior_level/largest_5_digit_in_a_series.js renamed to codewars/largest_5_digit_in_a_series.js

@@ -0,0 +1,5 @@
+Декларати́вное программи́рование — это парадигма программирования, в которой задаётся спецификация решения задачи, то есть описывается, что представляет собой проблема и ожидаемый результат. Противоположностью декларативного является императивное программирование, описывающее на том или ином уровне детализации, как решить задачу и представить результат. В общем и целом, декларативное программирование идёт от человека к машине, тогда как императивное — от машины к человеку. Как следствие, декларативные программы не используют понятия состояния, то есть не содержат переменных и операторов присваивания (см. также ссылочная прозрачность).
+Наиболее близким к «чисто декларативному» программированию является написание исполнимых спецификаций (см. соответствие Карри — Ховарда). В этом случае программа представляет собой формальную теорию, а её выполнение является одновременно автоматическим доказательством этой теории, и характерные для императивного программирования составляющие процесса разработки (проектирование, рефакторинг, отладка и др.) в этом случае исключаются: программа проектирует и доказывает сама себя.
+К подвидам декларативного программирования также зачастую относят функциональное и логическое программирование — несмотря на то, что программы на таких языках нередко содержат алгоритмические составляющие, архитектура в императивном понимании (как нечто отдельное от кодирования) в них также отсутствует: схема программы является непосредственно частью исполняемого кода[1].
+На повышение уровня декларативности нацелено языково-ориентированное программирование.
+«Чисто декларативные» компьютерные языки зачастую не полны по Тьюрингу — так как теоретически не всегда возможно порождение исполняемого кода по декларативному описанию. Это иногда приводит к спорам о корректности термина «декларативное программирование» (менее спорным является «декларативное описание решения» или, что то же самое, «декларативное описание задачи»).

codewars/largest_difference_in_increasing_indexes.js

@@ -0,0 +1,17 @@
+Императи́вное программи́рование — это парадигма программирования (стиль написания исходного кода компьютерной программы), для которой характерно следующее:
+
+в исходном коде программы записываются инструкции (команды);
+инструкции должны выполняться последовательно;
+при выполнении инструкции данные, полученные при выполнении предыдущих инструкций, могут читаться из памяти;
+данные, полученные при выполнении инструкции, могут записываться в память.
+Императивная программа похожа на приказы (англ. imperative — приказ, повелительное наклонение), выражаемые повелительным наклонением в естественных языках, то есть представляют собой последовательность команд, которые должен выполнить компьютер.
+
+При императивном подходе к составлению кода (в отличие от функционального подхода, относящегося к декларативной парадигме) широко используется присваивание. Наличие операторов присваивания увеличивает сложность модели вычислений и делает императивные программы подверженными специфическим ошибкам, не встречающимся при функциональном подходе[1].
+
+Основные черты императивных языков:
+
+использование именованных переменных;
+использование оператора присваивания;
+использование составных выражений;
+использование подпрограмм;
+и др.

codewars/junior_level/maximum_subarray.js renamed to codewars/maximum_subarray.js

@@ -0,0 +1,2 @@
+// CSP - Communicating Sequential Processes
+

codewars/next_bigger_number.js

@@ -0,0 +1,31 @@
+class Calculator {
+  constructor() {
+    this.VAT = 22;
+  }
+
+  sum(items) {
+    const items$ = Rx.Observable.from(items); // inject observable
+    return items$.map(value => value + (value * this.VAT / 100)).reduce((acc, value) => acc + value); // calculate
+  }
+}
+
+class Receipt {
+  constructor(calculator) {
+    this.calc = calculator;
+  }
+
+  print(...items) {
+    // Observable as an object that is wrapping the data and exposes some methods for manipulating the values
+    const total$ = this.calc.sum(items); // transforming the arguments to observable and return observable object
+    total$.subscribe(total => console.log(`total receipt $ ${total.toFixed(2)}`)); // subscribe and show result
+  }
+}
+
+const JEANS = 80.00,
+      SHIRT = 35.00,
+      SHOES = 90.00,
+      COAT = 140.00,
+      HAT = 29.00;
+const calc = new Calculator(),
+      receipt = new Receipt(calc);
+receipt.print(JEANS, SHIRT, SHOES, COAT, HAT);