codingvideo

function basicPartition(data, begin, end){
  const pivot = data[begin];
  let rightBegin = begin+1;
  for(let i=rightBegin; i<=end; i++){
    if(data[i] < pivot){
      swap(data, i, rightBegin);
      rightBegin++;
    }
  }
  const mid = rightBegin-1;

codingvideo

program add_one:
input => num_1
num_1 + 1 => sum
sum => output

program main:
input list => numbers
0 => sum
each input => item
  if item > 0

codingvideo

using System;

namespace Quick
{
    class Program
    {
        static void Main(string[] args)
        {
            var data = new int[] { 5, 2, 7, 4, 1, 6, 3 };
            Quicksort(data, 0, data.Length-1);

codingvideo

// abstract
function makeCount(limit, abstractMethods){

  let state = 0;

  const _state = function(stateChange){
    if(stateChange === undefined) 
      return state; 
    else
      state = stateChange(state);  

codingvideo

#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <iterator>
#include <limits>
using namespace std;

using Data = vector<int>;
using Words = vector<string>;

codingvideo

function createMockFetch(map){
  return function(url){ /* fetch mock */
    return { /* promise mock */
      then: function(){
        return { /* another promise mock */
          then: function(cb){
            let mockJson = map[url]();
            cb(mockJson);
          }
        };

codingvideo

class SwappableData(nums: Int*){

  private val data: Array[Int] = nums.toArray

  def swap(a: Int, b: Int): Unit = {
    if(a != b){
      val x = data(a)
      data(a) = data(b)
      data(b) = x
    }

codingvideo

import scala.io.StdIn.readLine

object LetsPracticeBinary extends App {

  def binaryToDecimal(input: String): Int = {
    val tokens = input.toList
    var total = 0
    var currPowerOfTwo = tokens.length - 1
    println("start", currPowerOfTwo)
    for (token <- tokens) {

codingvideo

object Quick extends App {

  def quicksort(data: Array[Int], begin: Int, end: Int): Unit = {
    if(begin < end){
      val mid = partition(data, begin, end)
      quicksort(data, begin, mid-1)
      quicksort(data, mid+1, end)
    }
  }

codingvideo

// entry function (recursive)
function mergeSort(arr, copy, first, last){

  // set if not given
  if(first === undefined && last === undefined && copy === undefined){
    first = 0;
    last = arr.length - 1;
    copy = _copy(arr);
  }