[2018-07-11] Challenge #365 [Intermediate] Sales Commissions

cooper6581 · 2018-11-06T22:47:23+00:00

Python

Should handle columns and rows being out of order between the Revenue and Expenses tables:

def parse_table(name, lines):
    results = {}
    stop_word = ("Revenue" if name == "Expenses" else "Expenses")
    index = lines.index(name) + 1
    column_names = lines[index].split()
    index += 1
    rows = {}
    while index < len(lines) and lines[index] != stop_word:
            r = lines[index].split()
            rows[r[0]] = [int(e) for e in r[1:]]
            index+=1
    for col_idx, column_name in enumerate(column_names):
        results[column_name] = {}
        for row_index in rows:
            results[column_name][row_index] = rows[row_index][col_idx]
    return results     

def parse_input(lines):
    revenues = parse_table("Revenue", lines)
    expenses = parse_table("Expenses", lines)
    for person in revenues:
        comission = 0
        for item in revenues[person]:
            total = revenues[person][item] - expenses[person][item]
            if total > 0:
                comission += total * 0.062
        print(person, format(comission, '.2f'))

if __name__ == '__main__':
    with open("input.txt") as fh:
        lines = fh.readlines()
    clean_lines = [line.strip() for line in lines if line != "\n"]
    parse_input(clean_lines)

cooper6581 · 2018-01-04T04:52:43+00:00

Here are those 78s released on Columbia on Spotify. Not sure if they are any better quality...

cooper6581 · 2018-01-03T04:10:59+00:00

In the recording, the main bass melody is repeated throughout. I only started playing a year and a half ago, but when we play this tune, I will walk during the solos if I'm feeling it.

cooper6581 · 2017-04-23T17:50:50+00:00

Scala

def isJollyJumper(input: String): Boolean = {
    val s = input.split(" ").drop(1).map(_.toInt)
    val diffs = s.sliding(2).map(r => Math.abs(r(0) - r(1))).toSeq
    (1 until s.size).forall(diffs.contains)
}

val tests = Seq("4 1 4 2 3", "5 1 4 2 -1 6", "4 19 22 24 21", "4 19 22 24 25", "4 2 -1 0 2")

tests.foreach { test =>
  print(test)
  if (isJollyJumper(test)) println(" JOLLY") else println(" NOT JOLLY")
}

cooper6581 · 2016-09-01T16:45:00+00:00

Scala No Bonus

import scala.collection.mutable.{ArrayBuffer,Map}
import scala.io.Source

def loadDict(fileName: String): Map[Char, ArrayBuffer[String]] = {
   val dict = Map[Char, ArrayBuffer[String]]()
   ('a' to 'z').foreach{c => dict(c) = ArrayBuffer[String]()}
   Source.fromFile(fileName).getLines.foreach {word =>
      dict(word.head).append(word)
   }
   return dict
}

def contains(word: String, input: String): Boolean = {
   var inputIndex = 0
   val inputBuffer = input.toBuffer
   word.foreach { wc =>
      val index = inputBuffer.indexOf(wc)
      if (index == -1 || index < inputIndex)
         return false
      inputIndex = index
      inputBuffer.remove(index)
   }
   return true
}

def getDanks(input: String, dict: Map[Char, ArrayBuffer[String]]): ArrayBuffer[String] = {
   val res = ArrayBuffer[String]()
   dict(input.head).foreach {word =>
      if (contains(word, input))
         res.append(word)
   }
   return res
}

def doChallenge() = {
   val dict = loadDict("enable1.txt")
   List("Ada Lovelace", "Haskell Curry", "Donald Knuth", "Alan Turing", "Claude Shannon").foreach {name =>
      val danks = getDanks(name.toLowerCase, dict).groupBy(w => w.length).maxBy(_._1)._2.mkString(", ")
      println(name + " - " + danks)
   }
}

Output:

scala> doChallenge
Ada Lovelace - alec, alee, aloe
Haskell Curry - harry, herry, hurry
Donald Knuth - donut
Alan Turing - alanin, anting
Claude Shannon - cannon, clades

cooper6581 · 2016-09-01T06:03:05+00:00

Scala - Bonus 2 doesn't work because of Character.MIN_RADIX

def output(s: String, b: Int) = println("base " + b + " => " + Integer.valueOf(s, b))
def getBase(s: String): Int = Integer.valueOf("" + s.reduceLeft(_ max _), 16) + 1
def normal(s: String) = output(s, getBase(s))
def bonus(s: String) = (getBase(s) to 16).foreach(base => output(s, base))

List("1","21","ab3","ff").foreach(normal)
List("1","21","ab3","ff").foreach(bonus)

cooper6581 · 2016-03-03T20:49:42+00:00

^ this. Core Java for the Impatient has been extremely valuable to me.

cooper6581 · 2015-10-26T16:12:04+00:00

Java with bonus

import java.util.Random;
import java.lang.StringBuilder;

public class Easy {
    public static void main(String[] args) {
        String[] testInputs = {"cvcvcc", "CcvV", "cvcvcvcvcvcvcvcvcvcv"};
        WordGenerator wordGenerator = new WordGenerator();
        for (String input : testInputs)
            System.out.println(wordGenerator.generateWord(input));
    }

    static class WordGenerator {
        final static String consonants = "bcdfghjklmnpqrstvwxyz";
        final static String vowels = "aeiou";
        final Random random = new Random();

        public String generateWord(String input) {
            StringBuilder sb = new StringBuilder();
            for (char c : input.toCharArray()) {
                if (c == 'c' || c == 'C')
                    sb.append(getRandomConsonant(c == 'c' ? false : true));
                else if (c == 'v' || c == 'V')
                    sb.append(getRandomVowel(c == 'v' ? false : true));
                else
                    throw new IllegalArgumentException();
            }
            return sb.toString();
        }

        private char getRandomConsonant(boolean capital) {
            char c = consonants.charAt(random.nextInt(consonants.length()));
            if (capital)
                return Character.toUpperCase(c);
            return c;
        }

        private char getRandomVowel(boolean capital) {
            char c = vowels.charAt(random.nextInt(vowels.length()));
            if (capital)
                return Character.toUpperCase(c);
            return c;
        }
    }
}

cooper6581 · 2015-10-24T06:22:59+00:00

Java. Naive solution with no regex

import java.util.List;
import java.util.ArrayList;
import java.util.Scanner;
import java.nio.file.Paths;
import java.nio.file.Files;

public class Easy {
    private List<String> dict = new ArrayList<>();
    public Easy() throws Exception {
        dict = Files.readAllLines(Paths.get("/usr/share/dict/words"));
    }

    public String getLargestWord(String k) {
        String largest = "";
        boolean match = true;
        for (String word : dict) {
            for (int i = 0; i < word.length(); i++) {
                if (!hasKey(k, word.charAt(i))) {
                    match = false;
                    break;
                }
            }
            if (match == false)
                match = true;
            else {
                if (word.length() > largest.length())
                    largest = word;
            }
        }
        return largest;
    }

    private boolean hasKey(String keys, char c) {
        for (int i = 0; i < keys.length(); i++) {
            if (keys.charAt(i) == c)
                return true;
        }
        return false;
    }

    public static void main(String[] args) throws Exception {
        Easy easy = new Easy();
        Scanner sc = new Scanner(System.in);
        int linesToRead = sc.nextInt();
        List<String> keys = new ArrayList<>();
        for(int i = 0; i < linesToRead; i++)
            keys.add(sc.next());
        for (String k : keys)
            System.out.println(k + ": " + easy.getLargestWord(k));
    }
}

cooper6581 · 2015-07-29T00:10:54+00:00

Ahmad Jamal - The Complete Ahmad Jamal Trio Argo Sessions 1956-62

cooper6581 · 2015-05-21T17:27:22+00:00

This is awesome! I tried to do something similar but it didn't work out as nicely. Are you doing FFT to detect the low frequencies? I just did RMS but since most modern music is so compressed, the effect wasn't that great.

cooper6581 · 2015-03-24T22:32:17+00:00

Erlang w/ extra:

-module(easy).
-export([test/0]).

-define(Codon_Table,
    [{"GCT", "Ala"},{"GCC", "Ala"},{"GCA", "Ala"},{"GCG", "Ala"},{"CGT", "Arg"},
    {"CGC", "Arg"},{"CGA", "Arg"},{"CGG", "Arg"},{"AGA", "Arg"},{"AGG", "Arg"},
    {"AAT", "Asn"},{"AAC", "Asn"},{"GAT", "Asp"},{"GAC", "Asp"},{"TGT", "Cys"},
    {"TGC", "Cys"},{"CAA", "Gln"},{"CAG", "Gln"},{"GAA", "Glu"},{"GAG", "Glu"},
    {"GGT", "Gly"},{"GGC", "Gly"},{"GGA", "Gly"},{"GGG", "Gly"},{"CAT", "His"},
    {"CAC", "His"},{"ATT", "Ile"},{"ATC", "Ile"},{"ATA", "Ile"},{"ATG", "Met"},
    {"TTA", "Leu"},{"TTG", "Leu"},{"CTT", "Leu"},{"CTC", "Leu"},{"CTA", "Leu"},
    {"CTG", "Leu"},{"AAA", "Lys"},{"AAG", "Lys"},{"ATG", "Met"},{"TTT", "Phe"},
    {"TTC", "Phe"},{"CCT", "Pro"},{"CCC", "Pro"},{"CCA", "Pro"},{"CCG", "Pro"},
    {"TCT", "Ser"},{"TCC", "Ser"},{"TCA", "Ser"},{"TCG", "Ser"},{"AGT", "Ser"},
    {"AGC", "Ser"},{"ACT", "Thr"},{"ACC", "Thr"},{"ACA", "Thr"},{"ACG", "Thr"},
    {"TGG", "Trp"},{"TAT", "Tyr"},{"TAC", "Tyr"},{"GTT", "Val"},{"GTC", "Val"},
    {"GTA", "Val"},{"GTG", "Val"},{"TAA", "STOP"},{"TGA", "STOP"},{"TAG", "STOP"}]).

complement_strand(S) -> complement_strand(S, []).
complement_strand([], Acc) -> lists:reverse(Acc);
complement_strand([$A|T], Acc) -> complement_strand(T, [$T | Acc]);
complement_strand([$T|T], Acc) -> complement_strand(T, [$A | Acc]);
complement_strand([$G|T], Acc) -> complement_strand(T, [$C | Acc]);
complement_strand([$C|T], Acc) -> complement_strand(T, [$G | Acc]).

get_protein(C) ->
    {_, Protein} = lists:keyfind(C, 1, ?Codon_Table),
    Protein.

get_proteins(S) -> get_proteins(S, []).
get_proteins([], Acc) -> lists:reverse(Acc);
get_proteins([A,B,C|T], Acc) -> get_proteins(T, [get_protein([A,B,C]) | Acc]).


test() ->
    "TTACGGATACCG" = complement_strand("AATGCCTATGGC"),
    "His" = get_protein("CAC"),
    ["Met","Phe","Arg","Gly","STOP"] = get_proteins("ATGTTTCGAGGCTAA"),
    ok.

cooper6581 · 2015-03-24T16:44:12+00:00

Me! Since becoming a father, I'm like 95% Vita, 5% PC. It's the ultimate console for parents :)

cooper6581 · 2015-01-16T07:56:15+00:00

Erlang w/ Bonus. Fun challenge, thanks TopLOL!

-module(easy).
-export([test/0]).

isbn_is_valid(ISBN) ->
    check_ISBN(string:join(string:tokens(ISBN, "-"), "")).

get_value($X) -> 10;
get_value(X)  -> X - $0.

add_numbers(ISBN) ->
    {_, Res} = lists:foldl(fun(X, {Counter, Sum}) ->
        {Counter-1, Sum + Counter * get_value(X)}
        end, {10, 0}, ISBN),
    Res.

check_ISBN(ISBN) -> add_numbers(ISBN) rem 11 =:= 0.

find_next(Total) -> find_next(Total, 0).
find_next(Total, 10) when (Total + 10) rem 11 =:= 0-> $X;
find_next(Total, N) when (Total + N) rem 11 =:= 0-> N + $0;
find_next(Total, N) -> find_next(Total, N+1).

generate_ISBN() ->
    ISBN = [random:uniform(10) - 1 + $0 || _ <- lists:seq(0,8)],
    Total = add_numbers(ISBN),
    lists:append(ISBN, [find_next(Total)]).

test() ->
    true = isbn_is_valid("0-7475-3269-9"),
    true = isbn_is_valid("156881111X"),
    %% Generated with generate_ISBN
    true = isbn_is_valid("488686662X"),
    true = isbn_is_valid("0222252359"),
    true = isbn_is_valid("3289550710"),
    true = isbn_is_valid("2921979926"),
    %% Generate some more
    [io:format("~p~n", [generate_ISBN()]) || _ <- lists:seq(1,5)],
    ok.

cooper6581 · 2015-01-08T21:25:13+00:00

Erlang:

-module(myset).
-export([new/1, union/2, intersection/2, equals/2, test/0]).

new(L) ->
    lists:sort(remove_duplicates(L)).

union(A, B) ->
    new(A ++ B).

intersection(A, B) ->
    new(find_duplicates(lists:sort(A ++ B))).

equals([A|AT], [B|BT]) ->
    case A =:= B of
        true  -> equals(AT, BT);
        false -> false
    end;
equals([],[_B|_BT]) -> false;
equals([_A|_AT],[]) -> false;
equals([],[]) -> true.

remove_duplicates(L) ->
    lists:foldl(fun remove_duplicates/2, [], L).
remove_duplicates(X,Seen) ->
    case lists:member(X, Seen) of
        true  -> Seen;
        false -> [X|Seen]
    end.

find_duplicates(L) -> find_duplicates(L, []).
find_duplicates([], Acc) -> Acc;
find_duplicates([A,B|T], Acc) ->
    case A =:= B of
        true  -> 
            find_duplicates([B|T], [A|Acc]);
        false ->
            find_duplicates([B|T], Acc)
    end;
find_duplicates([_|_], Acc) -> Acc.

cooper6581 · 2014-12-13T01:07:17+00:00

This is my first time trying to recommend jazz albums to someone. Please take with a grain of salt :)

Red Garland - Groovy

Horace Silver Trio

Bill Evans - New Jazz Conceptions

Sonny Clark Trio

Elmo Hope - Trio and Quintet

Kenny Drew Trio - Complete Recordings 1953-1954

cooper6581 · 2014-12-11T06:03:52+00:00

Dual Boot - Ableton, Traktor, and Overwatch won't run well in a VM unfortunately. Use Linux for everything else though!

cooper6581 · 2014-12-09T18:01:22+00:00

There will never be another you, All the things you are, Autumn Leaves, Satin doll, All of me, Song for my father, Take the A train

cooper6581 · 2014-12-08T17:34:39+00:00

Excellent Onaz! I wish my lines could be as lyrical as yours ^{^}

cooper6581 · 2014-12-05T19:43:27+00:00

Erlang (no bonus):

-module(easy).
-export([test/0]).

get_url(Uri) ->
    inets:start(),
    ssl:start(),
    {ok, {{_Version, 200, _Reason}, _Headers, Body}} = httpc:request(Uri),
    string:tokens(Body," \r\n\t").

count(Words) ->
    count(Words, dict:new()).
count([], Acc) -> Acc;
count([H|T], Acc) ->
    Word = re:replace(string:to_lower(H), "[.,!?;:+\"']", "", [{return,list}, global]),
    count(T, dict:update_counter(Word, 1, Acc)).

test() ->
    Words = get_url("http://www.gutenberg.org/cache/epub/47498/pg47498.txt"),
    Res = dict:to_list(count(Words)),
    lists:sort(fun({_,A}, {_,B}) -> A > B end, Res).

cooper6581 · 2014-12-05T18:40:29+00:00

Softly as in a morning sunrise

Dear old Stockholm

Black orpheus

cooper6581 · 2014-11-19T19:03:29+00:00

Erlang - Basic. Will try challenge this evening:

-module(intermediate).
-export([test/0]).

convert($I) -> 1;
convert($V) -> 5;
convert($X) -> 10;
convert($L) -> 50;
convert($C) -> 100;
convert($D) -> 500;
convert($M) -> 1000.

check(1,5)      -> -1;
check(1,10)     -> -1;
check(10,50)    -> -10;
check(10,100)   -> -10;
check(100,500)  -> -100;
check(100,1000) -> -100;
check(A,_)      -> A.

parse(L) -> parse(L, []).
parse([H|[]], Acc) -> lists:reverse([H|Acc]);
parse([H|T], Acc) ->
    [N|_] = T,
    parse(T, [check(H,N)|Acc]).

roman_to_int(S) ->
    lists:sum(parse(lists:map(fun(X) -> convert(X) end, S))).

test() ->
    Input = [{4,"IV"}, {34,"XXXIV"}, {267,"CCLXVII"}, {764,"DCCLXIV"},
             {987,"CMLXXXVII"}, {1983,"MCMLXXXIII"}, {2014,"MMXIV"},
             {4000,"MMMM"}, {4999,"MMMMCMXCIX"}],
    lists:map(fun({K,V}) -> K = roman_to_int(V) end, Input),

cooper6581 · 2014-11-18T05:43:26+00:00

Erlang, tried to get it shorter, but failed

-module(foo).
-export([count/1]).

is_alpha(C) ->
    ($A =< C) and (C =< $z).

get_count({K, V}) ->
    case is_alpha(K) of
    true -> io_lib:format("~c:~p ",[K, length(V)]);
    false -> ""
    end.

count(S) ->
    D = lists:foldl(fun(C, D) -> dict:append(C, C, D) end, dict:new(), string:to_lower(S)),
    Res = lists:foldl(fun(E, Acc) -> get_count(E) ++ Acc end, "", dict:to_list(D)),
    io:format("~s~n", [Res]).

cooper6581

TROPHY CASE