@kenbitanga

def counter(start=0) lambda { start += 1 } end count = counter() puts count.call puts count.call puts count.call

def fun yield if block_given? end prox = proc { puts 'proc' } lamb = lambda { puts 'lambda' } lamd = -> () { puts 'lambda shorthand' } fun() { puts 'block' } fun(&prox)

def compose(x, proc1, proc2) proc2.call(proc1.call(x)) end double = proc { |x| x * 2 } square = lambda { |x| x * x } triple = -> (x) { x * 3 } p compose(5, double, square) p compose(5, square, double)

class Integer def is_odd if self % 2 != 0 return true end return false end end p [1,2,3,4,5].filter(&:is_odd)

def greet(name) yield name end greet('calling a block using yield') { |x| puts x } def greet(name, &block) block.call(name) end

def compose(proc1, proc2): def wrapper(x): return proc2(proc1(x)) return wrapper def double(x): return x * 2 def square(x): return x * x

const compose = (proc1, proc2) => (x) => proc2(proc1(x)); const double = (x) => x * 2; const square = (x) => x * x; doubleThenSquare = compose(double, square) squareThenDouble = compose(square, double) console.log(doubleThenSquare(5))

def compose proc1, proc2 Proc.new do |x| proc2.call(proc1.call(x)) end end double = Proc.new do |x| x * 2 end

function* fib() { let a = 0, b = 1; while (true) { yield b; [a, b] = [b, a + b]; } } for (const i of fib()) { if (i > 55) break;

fib = Enumerator.produce([0, 1]) { |a, b| [b, a + b] } print fib.take(10).map(&:first)

fib = Enumerator.new do |enum| a, b = 0, 1 loop do enum.yield b a, b = b, a+b end end print fib.take(10)

const arr2obj = (arr, reverse = false, isValid = (x) => { return true }) => { let obj = {} arr.forEach((v, i) => { if (!(isValid(i))) return reverse ? obj[v] = i : obj[i] = v }) return obj }

a = Array.from('abcde') console.log('Input array') console.log(a) console.log('Using .reduce') b = a.reduce((a, c, i) => { if (i % 2 !== 0) return a return { ...a, [c]: i } }, {}) console.log(b)

const zip = (...arrs) => Array(Math.max(...arrs.map(a => a.length))) .fill() .map((_, i) => arrs.map(a => a[i]) ) const zap = (...arrs) => Array.from( Array(Math.max(...arrs.map(a => a.length))), (_, i)

import java.util.*; import java.lang.*; import java.io.*; class Main { private static int fib(int n) { if (n < 1) { return 0; } if (n < 3) { return 1; } HashMap<Integer, Integer> memo = new HashMap<>();

using System; using System.Collections.Generic; namespace MyCompiler { class Program { private static int Fib(int n) { if (n < 1) { return 0; }

package main import "fmt" func fib(n int) int { if n < 1 { return 0 } if n < 3 { return 1 } memo := make(map[int]int)

function fib(n) { if (n < 1) return 0 if (n < 3) return 1 const memo = new Map() if (!memo.has(n)) { memo.set(n, fib(n-1) + fib(n-2)) }

function fib(n) { if (n < 1) return 0 if (n < 3) return 1 return fib(n-1) + fib(n-2) } // decorator function function memoize(func) { const memo = new Map()

function fact(n) { const memo = new Map() if (n < 0) return undefined if (n < 2) return 1 if (!memo.has(n)) { memo.set(n, n * fact(n-1)) }