bluurn

#include <iostream>
#include <iomanip>
#include <vector>
#include <sstream>
#include <memory>
#include <cmath>

using namespace std;
const double PI = 3.14;

bluurn

require 'json'

module SerializableStruct
  class Dummy
    def self.members
      @members
    end

    def initialize(*vals)
      vals.each_with_index do |val, idx|

bluurn

#include <iostream>
#include <map>
#include <utility>
#include <vector>

using namespace std;

template <typename T>
T Sqr(T x) {
  return x * x;

bluurn

#include <iostream>
#include <sstream>
#include <cmath>
#include <map>
#include <vector>
#include <set>

using namespace std;

class Rational {

bluurn

/**
 * Constructor DependencyInjector
 * @param {Object} - object with dependencies
 */
var DI = function (dependency) {
  this.dependency = dependency;
};

// Should return new function with resolved dependencies
DI.prototype.inject = function (func) {

bluurn

const cartesian = (...arrays) => arrays.reduce((cartesianPart, array) => (
    [].concat(...
      cartesianPart.map(cartesianPartTuple =>
        array.map(it => cartesianPartTuple.concat(it))
      )
    )
  ), [[]]);


console.log(cartesian([1,2], [3,4], [5,6]))

bluurn

function flatten(arr) {
    return arr.reduce((acc, it) => 
        acc.concat((it instanceof Array) ? flatten(it) : it)
    , [])
}
flatten([[[1, [1.1]], 2, 3], [4, 5]]);

bluurn

class Graph {
  constructor() {
    this.adjList = new Map();
  }

  addVertex(v) {
    this.adjList.set(v, []);
    return this;
  }

bluurn

function Node(data) {
    this.data = data;
    this.parent = null;
    this.children = [];
}

function Tree(data) {
    this._root = new Node(data);
}

bluurn

class Queue {
  constructor() {
    this.items = [];
  }

  enqueue(obj) {
    this.items.push(obj);
  }

  dequeue() {