mzimecki

def find_needle(haystack)
  haystack.each_with_index do |elem, i|
    if elem.to_s.eql?(‘needle’)
      return “found the needle at position #{i}”
    end
  end
end

mzimecki

Studying for a Tech Interview Sucks, so Here's a Cheat Sheet to Help

This list is meant to be a both a quick guide and reference for further research into these topics. It's basically a summary of that comp sci course you never took or forgot about, so there's no way it can cover everything in depth. It also will be available as a gist on Github for everyone to edit and add to.

Data Structure Basics

###Array ####Definition:

• Stores data elements based on an sequential, most commonly 0 based, index.
• Based on tuples from set theory.

mzimecki

The introduction to Reactive Programming you've been missing

(by @andrestaltz)

So you're curious in learning this new thing called (Functional) Reactive Programming (FRP).

Learning it is hard, even harder by the lack of good material. When I started, I tried looking for tutorials. I found only a handful of practical guides, but they just scratched the surface and never tackled the challenge of building the whole architecture around it. Library documentations often don't help when you're trying to understand some function. I mean, honestly, look at this:

Rx.Observable.prototype.flatMapLatest(selector, [thisArg])

Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element's index and then transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.

mzimecki

package com.zimek.executors;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

mzimecki

import FileWrapper.wrap

/**
 * Views example: converting one type to other.
 */
class FileWrapper(val file: java.io.File) {
  def /(next: String) = new FileWrapper(new java.io.File(file, next))
  override def toString = file.getCanonicalPath()
}

mzimecki

def max[T](xs: T*)(implicit ord: Ordering[T]): T = xs.reduceLeft((a, b) => if (ord.gteq(a, b)) a else b)

mzimecki

object MergeSort {

  def msort[T](xs: List[T])(implicit ord: Ordering[T]): List[T] = {

    def merge(xs: List[T], ys: List[T]): List[T] = (xs, ys) match {
      case (Nil, ys) => ys
      case (xs, Nil) => xs
      case (x :: xs1, y :: ys1) =>
        if (ord.lt(x, y)) x :: merge(xs1, ys) else y :: merge(xs, ys1)
    }

mzimecki

object InsertionSort {

  def sort(list: List[Int]): List[Int] = {
    def insert(x: Int, xs: List[Int]): List[Int] = xs match {
      case List() => List(x)
      case y :: ys => if (x <= y) x :: xs else y :: insert(x, ys)
    }

    list match {
      case List() => List()

mzimecki

import scala.collection.immutable.HashMap
/**
 * hashCode and equals of mutable object (not working well because of object mutability)
 * the only way to make it working is to use immutable object
 */
class Point2(var x: Int, var y: Int) {
  def move(mx: Int, my: Int): Unit = {
    x = x + mx
    y = y + my
  }

mzimecki

def and(x: Boolean, y: =>Boolean) = if (x) y else false
def or(x: Boolean, y: =>Boolean) = if (x) true else y