module Warmup
    (change
    , stripQuotes
    , firstUppercasedOverLengthFive
    , powers
    , sumOfCubesOfOdds
    , swapAdjacents
    , Shape(Box, Sphere)
    , volume
    , surfaceArea)
    where

import Data.Char

change :: Int -> Either String (Int, Int, Int, Int)
change amount
    | amount < 0 = Left "amount cannot be negative"
    | otherwise = 
        let (quarters, afterQuarters) = amount `divMod` 25
            (dimes, afterDimes) = afterQuarters `divMod` 10
            (nickels, pennies) = afterDimes `divMod` 5
        in Right (quarters, dimes, nickels, pennies)

stripQuotes :: String -> String
stripQuotes s = filter (\c -> c /= '\'' && c /= '"') s

firstUppercasedOverLengthFive :: [String] -> Maybe String
firstUppercasedOverLengthFive [] = Nothing
firstUppercasedOverLengthFive (s:strings) 
    | length s > 5 = Just (map toUpper s)
    | otherwise = firstUppercasedOverLengthFive strings

powers :: Num a => a -> [a]
powers num = map (num^) [0..]

sumOfCubesOfOdds :: [Int] -> Int
sumOfCubesOfOdds [] = 0
sumOfCubesOfOdds (n:nums)
    | n `mod` 2 /= 0 = n * n * n + sumOfCubesOfOdds nums
    | otherwise = sumOfCubesOfOdds nums

swapAdjacents :: [a] -> [a]
swapAdjacents [] = []
swapAdjacents (a:b:remaining) = b:a:(swapAdjacents remaining)
swapAdjacents [a] = [a]

data Shape 
    = Sphere Double 
    | Box Double Double Double
    deriving (Eq, Show)

volume :: Shape -> Double
volume (Sphere r) = (4 / 3) * pi * r**3
volume (Box l w h) = l * w * h

surfaceArea :: Shape -> Double
surfaceArea (Sphere r) = 4 * pi * r**2
surfaceArea (Box l w h) = 2 * (h * w) + 2 * (h * l) + 2 * (w * l)

const crypto = require('crypto');
const rp = require('request-promise');

function change(cents) {
  if (cents < 0) {
    throw new RangeError('amount cannot be negative');
  }
  const denominations = [25, 10, 5, 1];
  const results = [];
  let remainingChange = cents;
  denominations.forEach((denomination, index) => {
    if (index < denominations.length - 1) {
      results[index] = Math.floor(remainingChange / denomination);
      remainingChange %= denomination;
    } else {
      results[index] = remainingChange;
    }
  });
  return results;
}

function stripQuotes(s) {
  return s.split(/['"]+/g).join('');
}

function scramble(s) {
  const array = s.split('');
  let currentIndex = array.length;
  let randomIndex;
  while (currentIndex !== 0) {
    randomIndex = Math.floor(Math.random() * currentIndex);
    currentIndex -= 1;
    [array[currentIndex], array[randomIndex]] = [array[randomIndex], array[currentIndex]];
  }
  return array.join('');
}

function powers(base, limit, callback) {
  let currentValue = 1;
  while (currentValue <= limit) {
    callback(currentValue);
    currentValue *= base;
  }
}

function* powersGenerator(base, limit) {
  let currentPower = 0;
  while (base ** currentPower <= limit) {
    yield base ** currentPower;

    currentPower += 1;
  }
}

function say(word) {
  return !word ? '' : nextWord => (nextWord ? say(`${word} ${nextWord}`) : word);

}

function interleave(a, ...b) {
  const [aLen, bLen, minLength] = [a.length, b.length, Math.min(a.length, b.length)];
  const interleaved = a.slice(0, minLength)
    .map((v, i) => [v, b[i]])
    .reduce((x, y) => [...x, ...y], []);
  return [...interleaved, ...(aLen < bLen ? b : a).slice(minLength)];
}

function cylinder(spec) {
  let { radius = 1, height = 1 } = spec;
  const volume = () => (Math.PI * (radius ** 2) * height);
  const surfaceArea = () => (2 * Math.PI * radius * height) + (2 * Math.PI * (radius ** 2));
  const widen = (factor) => { radius *= factor; };
  const stretch = (factor) => { height *= factor; };
  const toString = () => `Cylinder with radius ${radius} and height ${height}`;
  return Object.freeze({
    get radius() { return radius; },
    get height() { return height; },
    volume,
    surfaceArea,
    widen,
    stretch,
    toString,
  });
}

// https://www.w3schools.com/nodejs/ref_crypto.asp
function makeCryptoFunctions(cryptoKey, cryptoAlgorithm) {
  function encrypt(s) {
    const cipher = crypto.createCipher(cryptoAlgorithm, cryptoKey);
    let encryption = cipher.update(s, 'utf8', 'hex');
    encryption += cipher.final('hex');
    return encryption;
  }

  function decrypt(s) {
    const decipher = crypto.createDecipher(cryptoAlgorithm, cryptoKey);
    let decryption = decipher.update(s, 'hex', 'utf8');
    decryption += decipher.final('utf8');
    return decryption;
  }
  return [encrypt, decrypt];
}

function randomName(info) {
  const { gender, region } = info;
  const options = {
    method: 'GET',
    uri: 'https://uinames.com/api/',
    qs: {
      gender,
      region,
      amount: 1,
    },
    headers: {
      'User-Agent': 'Request-Promise',
    },
    json: true, // Automatically stringifies the body to JSON
  };
  return rp(options).then(data => `${data.surname}, ${data.name}`);
}

module.exports = {
  change,
  stripQuotes,
  scramble,
  powers,
  powersGenerator,
  say,
  interleave,
  cylinder,
  makeCryptoFunctions,
  randomName,
};

Awesome 98/100

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.Map;
import java.util.TreeMap;
import java.util.HashMap;
import java.util.regex.Pattern;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.Comparator;

public class StreamPractice {

    static Pattern nonWord = Pattern.compile("[^\\p{L}']+");

    public static Map<Integer, Long> wordCountByLength(BufferedReader reader) {
        // Return a tree map whose keys are word lengths
        // and corresponding values are the number of words
        // in the reader with that length.

        return reader.lines()
            .flatMap(line -> nonWord.splitAsStream(line.toLowerCase()))
            .filter(word -> !word.isEmpty())
            .collect(Collectors.groupingBy(w->w.length(), TreeMap::new, Collectors.counting()));
    }

    public static class Batter {
        String name;
        String team;
        int atBats;
        int hits;
        double average;
        Batter(String line) {
            String[] components = line.split("\\s*,\\s*");
            this.name = components[0];
            this.team = components[1];
            this.atBats = Integer.parseInt(components[2]);
            this.hits = Integer.parseInt(components[3]);
            this.average = (double)this.hits / (double)this.atBats;
        }

        @Override public String toString() {
          return this.name + " " + this.average;
        }
    }

    public static Map<String, Optional<Batter>> bestBatterByTeam(BufferedReader reader) {
        // Return a map that records, for each team, the b with
        // the highest average over all batters that have at least
        // 100 at-bats.
  
        return reader.lines()
            .map(b -> new Batter(b))
            .filter(a -> a.atBats >= 100)
            .collect(Collectors.groupingBy(b -> b.team, HashMap::new, Collectors.maxBy(Comparator.comparing(b -> b.average))));
    }

}

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.Map;
import java.util.TreeMap;
import java.util.HashMap;
import java.util.regex.Pattern;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.Comparator;

public class StreamPractice {

    static Pattern nonWord = Pattern.compile("[^\\p{L}']+");

    public static Map<Integer, Long> wordCountByLength(BufferedReader reader) {
        // Return a tree map whose keys are word lengths
        // and corresponding values are the number of words
        // in the reader with that length.

        return reader.lines()
            .flatMap(line -> nonWord.splitAsStream(line.toLowerCase()))
            .filter(word -> !word.isEmpty())
            .collect(Collectors.groupingBy(w->w.length(), TreeMap::new, Collectors.counting()));
    }

    public static class Batter {
        String name;
        String team;
        int atBats;
        int hits;
        double average;
        Batter(String line) {
            String[] components = line.split("\\s*,\\s*");
            this.name = components[0];
            this.team = components[1];
            this.atBats = Integer.parseInt(components[2]);
            this.hits = Integer.parseInt(components[3]);
            this.average = (double)this.hits / (double)this.atBats;
        }

        @Override public String toString() {
          return this.name + " " + this.average;
        }
    }

    public static Map<String, Optional<Batter>> bestBatterByTeam(BufferedReader reader) {
        // Return a map that records, for each team, the b with
        // the highest average over all batters that have at least
        // 100 at-bats.
  
        return reader.lines()
            .map(b -> new Batter(b))
            .filter(a -> a.atBats >= 100)
            .collect(Collectors.groupingBy(b -> b.team, HashMap::new, Collectors.maxBy(Comparator.comparing(b -> b.average))));
    }
}

# Homework2
import math
from random import sample
from cryptography.fernet import Fernet
import requests
from itertools import product


def change(cents):
    if cents < 0:
        raise ValueError('amount cannot be negative')
    denominations = [25, 10, 5, 1]
    results = [0] * len(denominations)
    remaining_change = cents
    for index, coin in enumerate(denominations):
        if index < len(denominations) - 1:
            results[index], remaining_change = divmod(remaining_change, coin)
        else:
            results[index] = remaining_change
    return tuple(results)


def strip_quotes(s):
    return s.replace('"', '').replace('\'', '')

def scramble(s):
    return ''.join(sample(s, k=len(s)))

def say(word=None):
    return '' if not word else lambda next=None: (say(f'{word} {next}') if next else word)


def triples(limit):
    return [(a, b, c) for a, b, c in product(range(1, limit + 1), repeat=3)
            if a < b < c and a ** 2 + b ** 2 == c ** 2]

def powers(base, limit):
    current_power = 0
    while base ** current_power <= limit:
        yield base ** current_power
        current_power += 1

def interleave(a, *b):
    min_len = min(len(a), len(b))
    interleaved = [val for pair in zip(a, b) for val in pair]
    return interleaved + (a[min_len:] if len(a) > len(b) else list(b)[min_len:])


class Cylinder():
    def __init__(self, radius=1, height=1):
        self.radius = radius
        self.height = height

    @property
    def volume(self):
        return math.pi * (self.radius ** 2) * self.height

    @property
    def surface_area(self):
        return (2 * math.pi * self.radius * self.height) + (2 * math.pi * (self.radius ** 2))

    def widen(self, factor):
        self.radius *= factor
        return self

    def stretch(self, factor):
        self.height *= factor
        return self


# https://cryptography.io/en/latest/
def make_crypto_functions(fernet_key):
    cipher = Fernet(fernet_key)

    def encrypt(bytes):
        return cipher.encrypt(bytes)

    def decrypt(bytes):
        return cipher.decrypt(bytes)
    return (encrypt, decrypt)

# https://www.dataquest.io/blog/python-api-tutorial/
def random_name(**data):
    params = {'amount': 1}
    if 'gender' in data:
        params.update({'gender': data['gender']})
    if 'region' in data:
        params.update({'region': data['region']})
    r = requests.get('https://uinames.com/api/', params=params)
    info = r.json()
    if 'error' in info:
        # raise ValueError(f'{{"error": "{info["error"]}"}}') ... f-string version
        raise ValueError('{"error": "' + info['error'] + '"}')
    return info['surname'] + ", " + info['name']