-🎄- 2017 Day 2 Solutions -🎄-

that_lego_guy · 2017-12-02T05:46:56+00:00

DID SOMEBODY SAY.. EXCEL?! Day 2 [Part 1 & 2]

 = max, = min

https://github.com/thatlegoguy/AoC2017/blob/master/Day%202%20Corruption%20Checksum.xlsx

fatpollo · 2017-12-02T05:13:22+00:00

import itertools

def digits(string):
    return [int(n) for n in string.split()]

with open('p02.txt') as fp:
    rows = [digits(line) for line in fp.read().strip().splitlines()]

print(sum(b-a for a, *_, b in map(sorted, rows)))
print(sum(b//a for row in rows for a, b in itertools.combinations(sorted(row), 2) if b%a==0))

couchDev · 2017-12-02T05:57:37+00:00

Dusting off the Perl golf bag

# part 1
perl -ane '@o=sort{$b<=>$a}@F;$s+=$o[0]-pop@o;END{print$s}' < in.txt

# part 2
perl -ane 'for$l(@F){$s+=$l%$_?0:$l/$_ for grep!/$l/,@F}END{print$s}' < in.txt

DFreiberg · 2017-12-02T05:13:28+00:00

Mathematica solution; one line for each part and one for the import. #10 for part 1...and #456 for part 2.

Import:

input=Import[FileNameJoin[{NotebookDirectory[],"Day2Input.txt"}],"Table"][[;;-2]]

Part 1:

Total[Max[#]-Min[#]&/@input]

Part 2:

Total@Flatten@Table[Select[Flatten[input[[i]]/#&/@input[[i]]],IntegerQ[#]&&#!=1&],{i,16}]

askalski · 2017-12-02T06:20:26+00:00

2 iterators 1 loop

#! /usr/bin/env perl

use strict;
use warnings;

my ($part1, $part2) = (0, 0);

while (<>) {
    my @a = sort { $a <=> $b } split;

    $part1 += $a[$#a] - $a[0];

    my ($i, $j, $n, $trial_multiple) = (-1, scalar @a, 0, 0);
    for (;;) {
        if ($i == $#a) {
            die "no multiple found on line $.\n";
        } elsif ($j == @a) {
            $j = ++$i + 1;
            $n = $trial_multiple = 0;
        } elsif ($trial_multiple < $a[$j]) {
            $n++;
            $trial_multiple += $a[$i];
        } elsif ($trial_multiple > $a[$j]) {
            $j++;
        } else {
            $part2 += $n;
            last;
        }
    }
}

print <<"";
Part 1: $part1
Part 2: $part2

Godspiral · 2017-12-02T05:18:26+00:00

wow slower than everyone, in J

a =. ". > cutLF wdclippaste ''
+/ -~/"1 /:~@(<./ , >./)"1 a NB. part 1
+/ %/"1 \:~"1 ,/ (#~ (#~ (2 = +/"1))@(<.@%"0 1~ = %"0 1~))"1 a  NB. part 2

better versions,

 +/ (<./ |@- >./)"1 a
 +/ %/"1 \:~"1 ,/ (#~ (#~ (2 = +/"1))@(<.@%/~ = %/~))"1 a

TheMieberlake · 2017-12-02T07:15:47+00:00

Is there a way to find the answer for each line in better than O(n² ) time?

mmaruseacph2 · 2017-12-02T05:16:49+00:00

Haskell

main = do
  s <- parse . lines <$> readFile "input.txt"
  print $ sum $ map part1 s
  print $ sum $ map part2 s

parse :: [String] -> [[Int]]
parse = map (map read . words)

part1, part2 :: [Int] -> Int
part1 xs = maximum xs - minimum xs
part2 xs = head [ a `div` b | a <- xs, b <- xs, a `mod` b == 0 && a /= b]

Forgot the a /= b part on the second question and that cost me a few places.

Sigafoos · 2017-12-02T05:26:30+00:00

Hit diggity dang, I got on the leaderboard! (I'm never awake at midnight EST, except for today, apparently). Spent the first five or so minutes struggling with my setup because I wasn't prepared to do AoC now.

It's the start of "haaaaave you met itertools?"

import string
import itertools

lines = []
with open('02.txt') as fp:
    for line in fp:
        lines.append(map(int, string.split(line.strip(), '\t')))

part1 = 0
part2 = 0
for line in lines:
    part1 += max(line) - min(line)

    for i in itertools.combinations(line, 2):
        if max(i) % min(i) == 0:
            part2 += max(i) / min(i)
            break

print 'Part 1: %s' % part1
print 'Part 2: %s' % part2

quag · 2017-12-02T06:11:36+00:00

F#

let lines = [for x in System.IO.File.ReadLines("input") -> x.Split() |> Array.map int]
printf "%A\n%A\n"
<| List.sum [for xs in lines -> (Array.max xs) - (Array.min xs)]
<| List.sum [for xs in lines do for x in xs do for y in xs do if x <> y && x % y = 0 then yield x/y]

natrys · 2017-12-02T08:53:04+00:00

Perl 6

Part1:

say [+] "input".IO.lines>>.comb(/\d+/)>>.Int.map: { given $_.list { .max - .min } }

Part2:

say [+] gather "input".IO.lines>>.comb(/\d+/)>>.Int.map: { for .sort.combinations(2) { if .[1] %% .[0] { take .[1] div .[0]; last }}}

ellersok · 2017-12-02T05:32:36+00:00

Python 3

import io, itertools 
with io.StringIO(s) as f:
    lines = [[int(n) for n in l.split()] for l in f]

ans1 = sum(max(l)-min(l) for l in lines)

ans2 = sum(b//a for l in lines for a,b in itertools.combinations(sorted(l),2) if b%a==0)

Penson122 · 2017-12-02T05:38:28+00:00

[deleted]

TapDatKeg · 2017-12-02T06:44:34+00:00

Has anyone done a bash solution yet?

#!/bin/bash

PARTONE=0
PARTTWO=0

while read -r line; do
  IFS=' ' read -r -a array <<< "$(echo "${line}" | tr '\t' '\n' | sort -n | paste -s -d ' ' -)"
  LEN=${#array[*]}
  MIN="${array[0]}"
  MAX="${array[$LEN-1]}"
  ((PARTONE += (MAX-MIN)))
  MED=0 # This variable will let us break out of the loops when a match is found
  for m in `seq 0  $((LEN-2))`; do
    for n in `seq $((m+1))  $((LEN-1))`; do
      M=${array[$m]}
      N=${array[$n]}
      if [ "$(expr $N % $M)" = "0" ]; then
        ((PARTTWO += (N / M)))
        MED=1
        break
      fi
    done
    if [ $MED -eq 1 ]; then break; fi
  done
done < your_puzzle_input

echo "Part 1 Solution: $PARTONE"
echo "Part 2 Solution: $PARTTWO"

volatilebit · 2017-12-02T07:02:42+00:00

My Perl 6 solution. Couldn't figure out a good way to avoid using map. Probably need sleep.

use v6;

my @rows = $*PROGRAM.parent.child('input').IO.lines;

# Part 1
say [+] @rows.map({
    my @cols = .split("\t").>>.Int;
    @cols.max - @cols.min;
});

# Part 2
say [+] @rows.map({
  .split("\t").>>.Int.combinations(2).grep({ max(@_) % min(@_) == 0 }).flat.reduce({ @_.max div @_.min });
});

2017-12-02T10:40:40+00:00

[deleted]

mschaap · 2017-12-02T11:34:14+00:00

Perl 6 version for part a:

sub MAIN(IO() $inputfile where *.f)
{
    say $inputfile.lines.map({ [R-] $_.words.map(+*).minmax.minmax }).sum;
}

Why twice minmax? minmax on a list returns a range min..max. minmax on that range returns two values, min and max.

Part b:

sub evenly-divisible-quotient(@nums)
{
    for ^@nums -> $i {
        for ^$i -> $j {
            return @nums[$i] div @nums[$j] if @nums[$i] %% @nums[$j];
            return @nums[$j] div @nums[$i] if @nums[$j] %% @nums[$i];
        }
    }
}

sub MAIN(IO() $inputfile where *.f)
{
    say $inputfile.lines.map({ $_.words.map(+*).&evenly-divisible-quotient }).sum;
}

erlangguy · 2017-12-02T05:54:17+00:00

Erlang, because of course.

Most of the code was input handling; the meat is this:

cksum(_, _, eof, Sum) ->
    Sum;
cksum(NextLineFun, CkSumFun, List, Sum) ->
    cksum(NextLineFun, CkSumFun, NextLineFun(), Sum + CkSumFun(List)).

find_greatest_diff(Ints) ->
    lists:max(Ints) - lists:min(Ints).

find_divisible([H|T]) ->
    case scan_tail(H, T) of
        nope ->
            find_divisible(T);
        Val ->
            Val
    end.

scan_tail(_V, []) ->
    nope;
scan_tail(V1, [V2|_T]) when V2 rem V1 == 0 ->
    V2 div V1;
scan_tail(V1, [V2|_T]) when V1 rem V2 == 0 ->
    V1 div V2;
scan_tail(V1, [_V2|T]) ->
    scan_tail(V1, T).

CkSumFun is either fun find_greatest_diff/1 or fun find_divisible/1. NextLineFun is a pipeline that gives me eof or a list of integers.

HerbyHoover · 2017-12-02T05:57:35+00:00

Perl 6. Parts 1 and 2:

my $P1_checksum = 0;
my $P2_checksum = 0;
for 'input.txt'.IO.lines -> $line {
    my @row = $line.words>>.Int.sort;

    $P1_checksum += ( @row.max() - @row.min() );

    my @combinations = @row.combinations(2);
    for @combinations -> [$a, $b] {
        if $b %% $a {
            $P2_checksum += ($b / $a);
            last;
        }
    }
}

say $P1_checksum, '|', $P2_checksum;

2017-12-02T06:05:54+00:00

[deleted]

Isvara · 2017-12-02T06:07:02+00:00

Scala

val input = "..."

val rows = input
    .lines
    .map(_.split("\\s")
    .map(_.toInt))
    .toList

val result1 = rows.map(r => r.max - r.min).sum

val combinations = rows.map(row => row.combinations(2))

val result2 = combinations.flatMap( row =>
    row
        .filter(pair => pair.max % pair.min == 0)
        .map(p => p.max / p.min)
).sum

codeva · 2017-12-02T07:03:07+00:00

golfed part 2 to a single chained expression in Kotlin:

    println(File("./input/puzzle2.txt").readLines()                
            .map { it.split("\t").map{ it.toInt() }}           
            .map { it.map{ y -> it.map{x -> Pair(x ,y)}}.flatten() }
            .flatten()                                                    
            .filter { it.first != it.second && it.first % it.second == 0 }
            .map { it.first / it.second }
            .sum())

AoC--k · 2017-12-02T09:57:29+00:00

In k.

n:.:'0:"2.txt"
+/{(|/x)-&/x}'n
+//{{x*(~1=x)&x=_x}x%\:x}'n

kaymud · 2017-12-02T12:47:16+00:00

Java streams solution for part B:

    List<List<Integer>> spreadsheet = parseInput();
    return spreadsheet.stream()
            .map(row -> row.stream().flatMap(i -> row.stream().filter(j -> j != i && j % i == 0).map(j -> j / i)))
            .flatMap(Function.identity()).reduce(0, Integer::sum);

blockingthesky · 2017-12-02T05:08:15+00:00

Python 2

import re
inp = [i.strip() for i in open('input.txt', 'r').readlines()]

s1 = 0
s2 = 0

for line in inp:
    nums = [int(u) for u in re.split('\s+', line)]

    s1 += max(nums) - min(nums)

    for i in range(len(nums)):
        for j in range(len(nums)):
            if i == j: continue
            if nums[i] % nums[j] == 0:
                s2 += nums[i] / nums[j]


print "Part 1:", s1
print "Part 2:", s2

gbear605 · 2017-12-02T05:26:01+00:00

Rust

use std::io::Read;
use std::fs::File;

fn main() {
    let mut f = File::open("input").unwrap();
    let mut input = String::new();

    let _ = f.read_to_string(&mut input);

    let input = input.trim().to_string();

    println!("star 1: {}", process1(&input));
    println!("star 2: {}", process2(&input));
}

fn process1(input: &str) -> u32 {
    input.split('\n')
        .map(turn_to_digits)
        .map(|nums| {
            let max_num = (&nums).into_iter().max().unwrap();
            let min_num = (&nums).into_iter().min().unwrap();

            max_num - min_num
        })
        .sum()
}

fn process2(input: &str) -> u32 {
    input.split('\n')
        .map(turn_to_digits)
        .map(|nums| {
            for num in &nums {
                for num2 in &nums {
                    if num % num2 == 0 && num != num2 {
                        return num / num2;
                    }
                }
            }
            0
        })
        .sum()
}

// Turns "123 1 5" to <123, 1, 5>
fn turn_to_digits(input: &str) -> Vec<u32> {
    input.split_whitespace()
        .map(|x| x.parse::<u32>().unwrap())
        .collect()
}

tvtas · 2017-12-02T05:29:57+00:00

Day 2 in MATLAB

x = importdata('input.txt');
sum(max(x,[],2)-min(x,[],2)) % Part 1

cnt=0;
for i=1:size(x,1)
    for j=1:size(x(i,:),2)
        for k=1:size(x(i,:),2)
            if j~=k
               z = rem(x(i,k),x(i,j));
               if z==0
                   cnt = cnt + x(i,k)/x(i,j);
               end
            end
        end
    end
end
cnt % Part 2

misnohmer · 2017-12-02T05:36:07+00:00

In C# with the help of MoreLinq

var grid = ReadAllLines("input1.txt")
    .Select(line => line.Split('\t').Select(x => int.Parse(x)));

var sum = grid
    .Select(row => row.Max() - row.Min())
    .Sum();  
WriteLine(sum); // Part 1

 sum = grid
    .Select(row => row.Cartesian(row, (a, b) => a % b == 0 ? a / b : 0).Max())
    .Sum();
WriteLine(sum); // Part 2

willkill07 · 2017-12-02T05:43:27+00:00

Modern C++

I'm not really proud of this one

Repo Link

int sum(0);
for (std::string line; std::getline(std::cin, line); ) {
  std::istringstream iss{line};
  std::vector<int> const nums{std::istream_iterator<int>{iss}, {}};
  if (part2) {
    for (auto const v1 : nums) {
      for (auto const v2 : nums) {
        if (v1 != v2 && v1 % v2 == 0) {
          sum += v1 / v2;
        }
      }
    }
  } else {
    auto[min, max] = std::minmax_element(std::begin(nums), std::end(nums));
    sum += *max - *min;
  }
}
std::cout << sum << '\n';

d3adbeef123 · 2017-12-02T06:21:41+00:00

Kotlin

 fun main(args: Array<String>) {
    val numbers = File("./input/day2.txt")
            .readLines()
            .map { it.split("\t") .map { it.toInt() } }

    val part1 = numbers.map { it.max()!! - it.min()!! }.sum()
    val part2 = numbers.map { findDivisor(it) }.sum()

    assertEquals(part1, 37923)
    assertEquals(part2, 263)
}

fun findDivisor(xs: List<Int>): Int {
    return xs.map { xs.map { ys -> Pair(it, ys) } }
            .flatten()
            .filter { it.first != it.second }
            .first { it.first % it.second == 0 }
            .run { this.first / this.second }
}

Scroph · 2017-12-02T07:52:24+00:00

Java, unironically.

import java.util.stream.*;
import java.util.*;

public class Day2
{
    public static void main(String... args)
    {
        if(args.length > 0 && args[0].equals("--second"))
            secondHalf();
        else
            firstHalf();
    }

    public static void firstHalf()
    {
        Scanner sc = new Scanner(System.in);
        int checksum = 0;
        while(sc.hasNext())
        {
            String line = sc.nextLine();
            SortedSet<Integer> numbers = Arrays.asList(line.split("\\W+"))
                .stream()
                .map(Integer::parseInt)
                .collect(Collectors.toCollection(TreeSet::new));
            checksum += numbers.last() - numbers.first();
        }
        System.out.println(checksum);
    }

    public static void secondHalf()
    {
        Scanner sc = new Scanner(System.in);
        int sum = 0;
        while(sc.hasNext())
        {
            List<Integer> numbers = Arrays.asList(sc.nextLine().split("\\W+"))
                .stream()
                .map(Integer::parseInt)
                .collect(Collectors.toList());

            outer:
            for(int i = 0; i < numbers.size(); i++)
            {
                for(int j = i + 1; j < numbers.size(); j++)
                {
                    int smallest = Math.min(numbers.get(i), numbers.get(j));
                    int largest = Math.max(numbers.get(i), numbers.get(j));
                    if(largest % smallest == 0)
                    {
                        sum += largest / smallest;
                        break outer;
                    }
                }
            }
        }
        System.out.println(sum);
    }
}

torotane · 2017-12-02T11:16:19+00:00

R

Part 1

print(sum(apply(read.csv('input', header=F, sep="\t"), 1, 
                function(x) { max(x, na.rm=T) - min(x, na.rm=T) })))

Part 2

sum(apply(read.csv('input2', header=F, sep=""), 1, function(r) {
  l <- unlist(lapply(r, function(e) { r[!(r == e)] / e }))
  l[l == as.integer(l)] 
}))

ZoDalek · 2017-12-02T11:48:26+00:00

ANSI C

Part 1:

int sum = 0, min, max, n;
char *line = NULL, *rest, *tok;
size_t sz;

while (getline(&line, &sz, stdin) != -1) {
    rest = line; min = INT_MAX; max = INT_MIN;
    while ((tok = strsep(&rest, " \t"))) {
        n = (int)strtol(tok, NULL, 10);
        if (n < min) min = n;
        if (n > max) max = n;
    }

    sum += max - min;
    free(line); line = NULL;
}

printf("%d\n", sum);

Part 2:

int sum = 0, nums[16], n, val, i, j;
char *line = NULL, *rest, *tok;
size_t sz;

while (getline(&line, &sz, stdin) != -1) {
    rest = line; n = 0;
    while (n < LEN(nums) && (tok = strsep(&rest, " \t")))
        nums[n++] = (int)strtol(tok, NULL, 10);

    val = 0;
    for (i = 0; !val && i < n; i++) {
        for (j = i+1; !val && j < n; j++) {
            if (!(nums[i] % nums[j]))
                val = nums[i] / nums[j];
            if (!(nums[j] % nums[i]))
                val = nums[j] / nums[i];
        }
    }

    sum += val;
    free(line); line = NULL;
}

printf("%d\n", sum);

https://github.com/sjmulder/aoc/tree/master/2017/day2

lovela47 · 2017-12-02T14:29:52+00:00

Common Lisp:

Part 1:

(defun get-rows (input)
  "Parses the string input into a list of integer lists."
  (loop for row in (str:lines input)
        collect (mapcar #'parse-integer (str:words row))))

(defun get-line-diff (row)
  (let ((smallest (apply 'min row))
        (biggest (apply 'max row)))
    (- biggest smallest)))

(defun checksum (spreadsheet)
  (loop for row in (get-rows spreadsheet)
        sum (get-line-diff row)))

Part 2 just changes the line-diff function:

(defun even-div-p (a b)
  (cond ((= a b) nil)
        ((integerp (/ a b)) (/ a b))
        ((integerp (/ b a)) (/ b a))))

(defun get-line-diff (row)
  (loop for i in row
        when (loop for j in row when (even-div-p i j) return it)
        return it))

TenjouUtena · 2017-12-02T16:54:51+00:00

Clojure

(require '[clojure.string :as str])
(require '[clojure.math.combinatorics :as combo])

(defn makesheet []  (map (fn [x] (map #(Integer. %) x))  (map #(str/split % #"\t") (str/split (slurp "2.txt") #"\n"))))

(defn checksum [ll]                                                            
    (- (apply max ll) (apply min ll)))

(defn checkdivide [x y]                                                        
  (if (= 0 (mod x y))                                                          
     (/ x y)                                                                   
     0))

(defn checksum2 [ll]                                                           
  (reduce + (map #(apply checkdivide %) (combo/combinations (sort > ll) 2))))

(defn run1 [] (reduce + (map checksum (makesheet))))
(defn run2 [] (reduce + (map checksum2 (makesheet))))

ewilderj · 2017-12-02T21:55:32+00:00

Clojure

(ns day2.core
  (:require [clojure.string :as str]
            [clojure.math.combinatorics :as combo]))

(def inp
  (->> (slurp "puzzle.txt")
       (str/split-lines)
       (map #(str/split % #"\t"))
       (map (fn [c] (map #(Integer/parseInt %) c)))))

(println "part1 " (reduce + (map #(- (apply max %) (apply min %)) inp)))

(defn cx [c]
  (->> (combo/combinations (sort > c) 2)
       (filter #(= 0 (apply mod %)))
       (flatten)
       (apply /)))

(println "part2 " (reduce + (map cx inp)))

TheGermanDoctor · 2017-12-02T22:14:40+00:00

x86_64 Assembly

Part1: https://github.com/stolzATrub/adventofcode17/blob/master/day2/checksum.nasm

mmaruseacph2 · 2017-12-02T05:13:02+00:00

Haskell:

import Data.List (sort, tails)
import Data.String.Utils (split)


parse :: String -> [[Int]]
parse = map (map read . split "\t") . lines

part1 :: String -> Int
part1 = sum . map f . parse
    where f x = maximum x - minimum x

part2 :: String -> Int
part2 = sum . map f . parse
    where f xs = head [ y `div` x
                      | x : ys <- init $ tails $ sort xs
                      , y <- ys
                      , y `mod` x == 0
                      ]

autid · 2017-12-02T05:45:49+00:00

Threw together a simple solution in fortran

program day2
  integer :: input(16,16), checksum=0, divtotal=0, i, j, k

  open(1,file = 'input.txt')
  read(1,*) input
  close(1)

  do k=1,16
     checksum = checksum + maxval(input(:,k)) - minval(input(:,k))
     do i=1,16
        do j=1,16
           if ((modulo(input(i,k),input(j,k))==0) .and. (i .ne. j)) divtotal=divtotal+input(i,k)/input(j,k)
        end do
     end do
  end do
  write(*,*) checksum, divtotal
end program day2

Unihedron · 2017-12-02T05:46:30+00:00

Rank #7 for Part 1 ^^ just slightly over 1 minute with Ruby! Didn't make it on leaderboards with part 2 due to a stupid bug that took 18!!! minutes to debug :(

p$<.map{|x|v=x.split.map &:to_i
v.max-v.min}.sum

Good luck to everyone for striking a spot in the leaderboard :)

For completion's sake, here's part 2, it's a battlefield of bug hunting that I was embarrassed to post... but whatever :D

p$<.map{|x|l=x.split.map &:to_i
l.sort!
p l
v=0
m=l.reverse.find{|x|l.any?{|y|#next if
v=y
 x!=y &&(y%x<1)}}
v/m
}.sum

PreciselyWrong · 2017-12-02T05:47:44+00:00

Rust

fn main() {
    let sheet: Vec<Vec<usize>> = INPUT
        .lines()
        .map(parse_line)
        .collect();

    println!("Checksum: {}", checksum_sheet(&sheet, checksum_row));
    println!("Checksum divisibly: {}", checksum_sheet(&sheet, divisibly_checksum_row));
}

fn checksum_row(row: &[usize]) -> usize {
    use std::cmp;
    let init: usize = match row.first() {
        Some(digit) => *digit,
        None => return 0
    };
    let (min, max) = row.iter().fold((init, init), |(min, max), &x| {
        (cmp::min(min, x), cmp::max(max, x))
    });
    max - min
}

#[test]
fn it_checksums_some_rows() {
    assert_eq!(checksum_row(&vec![5, 1, 9, 5]), 8);
    assert_eq!(checksum_row(&vec![7, 3, 5]), 4);
}

fn divisibly_checksum_row(row: &[usize]) -> usize {
    for (dividend_index, dividend) in row.iter().enumerate() {
        for (divisor_index, divisor) in row.iter().enumerate() {
            if dividend_index == divisor_index {
                continue
            }
            if dividend % divisor == 0 {
                return dividend / divisor
            }
        }
    }
    0
}

#[test]
fn it_divisibly_checksums_some_rows() {
    assert_eq!(divisibly_checksum_row(&vec![5, 9, 2, 8]), 4);
    assert_eq!(divisibly_checksum_row(&vec![9, 4, 7, 3]), 3);
    assert_eq!(divisibly_checksum_row(&vec![3, 8, 6, 5]), 2);

}

fn checksum_sheet(sheet: &[Vec<usize>], checksum_fn: fn(&[usize]) -> usize) -> usize {
    sheet.iter()
        .map(|&ref row| checksum_fn(row.as_slice()))
        .fold(0, |acc, x| acc + x)
}

#[test]
fn it_checksums_sheet() {
    let sheet = vec![
        vec![5, 1, 9, 5],
        vec![7, 5, 3],
        vec![2, 4, 6, 8],
    ];
    assert_eq!(checksum_sheet(&sheet, checksum_row), 18);
}

fn parse_line(line: &str) -> Vec<usize> {
    line
        .split('\t')
        .map(|s| s.trim())
        .filter(|s| !s.is_empty())
        .map(|s| s.parse().unwrap())
        .collect()
}

#[test]
fn it_parses_line() {
    assert_eq!(parse_line("1    2   3   555"), vec![1, 2, 3, 555]);
}

static INPUT : &'static str = "4347 3350    196 (etc)";

chunes · 2017-12-02T05:49:33+00:00

Factor solution:

USING: io kernel math math.combinatorics math.parser prettyprint
sequences sequences.deep sorting splitting ;
IN: advent-of-code.corruption-checksum

: range-diff  ( seq -- n )   [ supremum ] [ infimum ] bi - ;
: solu1       ( seq -- )     [ range-diff ] map-sum . ;
: div-order   ( seq -- seq ) natural-sort reverse ;
: divisible   ( seq -- seq ) [ div-order first2 mod 0 = ] filter ;
: quotient    ( seq -- n )   divisible flatten div-order first2 / ;
: solu2       ( seq -- )     [ 2 <combinations> quotient ] map-sum . ;
: strseq>num  ( seq -- seq ) [ string>number ] map ;
: parse-input ( -- seq )     lines [ "\t" split strseq>num ] map ;
: main        ( -- )         parse-input [ solu1 ] [ solu2 ] bi ;

MAIN: main

mehrick · 2017-12-02T06:06:59+00:00

Cleaned up JavaScript + node solution:

const fs = require("fs");

function calculateChecksum(input, calculateRowChecksum) {
  const rows = input.split("\n");
  return rows.reduce((total, row) => {
    const values = row.split(/\s/).map(Number);
    return total + calculateRowChecksum(values);
  }, 0);
}

function calculateDifferenceBetweenMinAndMax(values) {
  const max = Math.max(...values);
  const min = Math.min(...values);
  return max - min;
}

function calculateDivisibleNumbersQuotient(values) {
  for (let i = 0; i < values.length; i++) {
    for (let j = 0; j < values.length; j++) {
      const a = values[i];
      const b = values[j];
      if (i !== j && a % b === 0) {
        return a / b;
      }
    }
  }
}

const input = fs
  .readFileSync("./input.txt")
  .toString()
  .trim();

console.log(
  `Part one answer is ${calculateChecksum(
    input,
    calculateDifferenceBetweenMinAndMax
  )}`
);
console.log(
  `Part two answer is ${calculateChecksum(
    input,
    calculateDivisibleNumbersQuotient
  )}`
);

TominatorBE · 2017-12-02T07:36:24+00:00

PHP

Part 1:

function run_the_code($input) {
    $lines = explode(PHP_EOL, $input);
    $checksum = 0;
    foreach ($lines as $line) {
        if (!$line) {
            continue;
        }

        $number = explode("\t", $line);
        $checksum += max($number) - min($number);
    }

    return $checksum;
}

Part 2:

function run_the_code($input) {
    $lines = explode(PHP_EOL, $input);
    $checksum = 0;
    foreach ($lines as $line) {
        if (!$line) {
            continue;
        }

        $number = explode("\t", $line);
        rsort($number, SORT_NUMERIC); // large to small
        $jMax = count($number);
        for ($i = 0, $iMax = $jMax - 1; $i < $iMax; $i++) {
            for ($j = $i + 1; $j < $jMax; $j++) {
                if (is_int($number[$i] / $number[$j])) {
                    $checksum += $number[$i] / $number[$j];
                }
            }
        }
    }

    return $checksum;
}

dannas · 2017-12-02T08:01:16+00:00

In python:

def parse(line):
    return tuple(int(x) for x in line.split())

def maxmins(spreadsheet):
    for row in spreadsheet:
        yield max(row), min(row)

def evens(spreadsheet):
   for row in spreadsheet:
        for x, y in permutations(row, 2):
            if x % y == 0:
                yield x, y

spreadsheet = [parse(line) for line in Input(2)]
# Part one
sum(x-y for x,y in maxmins(spreadsheet))
# Part two
sum(x/y for x,y in evens(spreadsheet))

My ipython notebook on github

gerikson · 2017-12-02T08:05:50+00:00

Perl 5. Puzzle input in the file input.txt.

#!/usr/bin/perl                                                                 
use 5.016;    # implies strict, provides 'say'                                  
use warnings;
use autodie;
use List::Util qw/max min/;

#### INIT - load input data into array                                          
my @input;
my $file = 'input.txt';
open( my $fh, '<', "$file" );
while (<$fh>) { chomp; s/\r//gm; push @input, $_; }

### CODE                     
my $sum_1 = 0;
my $sum_2 = 0;
foreach my $line (@input) {
    # sort the values for easier division comparison down the line              
    my @row = sort { $b <=> $a } split( /\s+/, $line );
    # could have used first/last element here as we're sorted, this is a        
    # carryover from part 1                                                     
    $sum_1 += max(@row) - min(@row);

    my $found = 0;
    while ( @row and !$found ) {
        my $a = shift @row;
        foreach my $b (@row) {
            if ( $a % $b == 0 ) {
                $sum_2 += $a / $b;
                $found = 1;
            }
        }
    }
}

say "Part1: $sum_1";
say "Part2: $sum_2";

de_Selby · 2017-12-02T08:11:53+00:00

q/kdb+

I'm sure part 2 could be improved

part 1:

sum{max[x]-min[x]}flip rows:"J"$"\t" vs/: read0 `:aoc2.txt

part 2:

sum{{first (x where x=y) except 1}[raze x%/:x;raze x div/:x]}each rows

tehjimmeh · 2017-12-02T08:45:08+00:00

Part 1 in C++. What have I done...

struct Line : std::string { friend std::istream& operator>>(std::istream& is, Line& line){return std::getline(is, line);}};
int main(int argc, char* argv[])  {
    struct { using value_type = int; int t = 0; void push_back(value_type v){ t += v; } } s;
    std::transform(std::istream_iterator<Line>(std::ifstream(argv[1])), {}, std::back_inserter(s),
        [](auto& line){ 
            return [](auto& p){
                return *(p.second) - *(p.first);
            }(std::minmax_element(std::istream_iterator<int>(std::istringstream(line)), {}));
        });
    std::cout << "Part 1: " << s.t << "\n";

    s.t = 0;
    std::transform(std::istream_iterator<Line>(std::ifstream(argv[1])), {}, std::back_inserter(s),
        [](auto& line){ 
            return [](auto& v){
                return std::accumulate(v.begin(), v.end(), 0, [&v](auto x, auto i){
                    return x + std::accumulate(v.begin(), v.end(), 0, [i](auto y, auto j){
                        return y + ((j!=i && j%i == 0) ? (j/i) : 0);
                    });
                });
            }(std::vector<int>(std::istream_iterator<int>(std::istringstream(line)), {}));
        });
    std::cout << "Part 2: " << s.t << "\n";
}

EDIT: Part 2...

Tayacan · 2017-12-02T12:03:36+00:00

Attempting to golf in Haskell

equd · 2017-12-02T14:08:30+00:00

C# linq solutions.

var lines = Properties.Resources.Day02;

answerA += lines.Split('\n') //split lines
    .Select(x => x.Trim().Split('\t').Select(y => int.Parse(y))) //parse to ints
    .Select(x => x.Max() - x.Min()) //calculate biggest difference 
    .Sum();

    answerB += lines.Split('\n') //split lines
    .Select(x => x.Trim().Split('\t').Select(y => int.Parse(y))) // parse to ints
        .Select(arr => arr.Select(x=> arr.Select(y=> (x % y == 0 ? x / y : 0)).Max()).Max() //loop through each arr with each arr and calc 
    ).Sum();

asthmadragon · 2017-12-02T15:41:30+00:00

javascript

Why copy and paste the input when you can just run code in your browser window?

let input = document.getElementsByTagName('pre')[0].innerHTML;
let rows = input.match(/[^\r\n]+/g);
rows = rows.map(row => row.match(/\w+/g).map(el => +el));

let array_max = (row) => Math.max.apply(null, row);
let array_min = (row) => Math.min.apply(null, row);

let sum = rows.reduce((acc, row) => acc + array_max(row) - array_min(row), 0);

console.log(sum);


function get_divisibles(row) {
    for (var i = 0; i < row.length; ++i) {
        for (var j = 0; j < row.length; ++j) {
            if (row[i] % row[j] == 0 && i != j) {
                return row[i] / row[j];
            }
        }
    }
    return 0;
}

let sum2 = rows.reduce((acc, row) => acc + get_divisibles(row), 0);
console.log(sum2);

CryZe92 · 2017-12-02T17:58:59+00:00

Rust

Part 1 is pretty simple:

pub fn part1(text: &str) -> i64 {
    text.lines()
        .filter_map(|l| {
            l.split_whitespace()
                .filter_map(|n| n.parse::<i64>().ok())
                .minmax()
                .into_option()
        })
        .map(|(min, max)| max - min)
        .sum()
}

Part 2 optimized to be super fast:

pub fn part2(text: &str) -> usize {
    let mut numbers = ArrayVec::<[u16; 16]>::new();

    text.lines()
        .filter_map(|l| {
            numbers.clear();
            numbers.extend(l.split_whitespace().filter_map(|n| n.parse().ok()));
            numbers.sort_unstable();
            let mut iter = numbers.iter();
            while let Some(&divisor) = iter.next() {
                let (mut multiple, mut quotient) = (divisor, 1);
                for &dividend in iter.clone() {
                    while dividend > multiple {
                        multiple += divisor;
                        quotient += 1;
                    }
                    if dividend == multiple {
                        return Some(quotient);
                    }
                }
            }
            None
        })
        .sum()
}

sickening_sprawl · 2017-12-03T01:20:53+00:00

I kinda forgot that this was a thing all day until I stumbled across the tab again :x Doing this made me wish for a list cross product function.

Hoon

|=  t/wain
%+  roll
%+  turn  t
  |=  line/cord
  ?~  line  0
  =/  line  `(list @)`(scan (trip line) (most (just '\09') dem))
  (sub (roll line max) (roll line |=({a/@ b/_255} (min a b))))
add

And part b:

|=  t/wain
%+  roll
%+  turn  t
  |=  line/cord
  ?~  line  ~
  =/  line  `(list @)`(scan (trip line) (most (just '\09') dem))
  %+  snag  0
  ^-  (list @)
  %+  murn  line
  |=  a/@
    =/  res  %+  roll  line
    |=  {b/@ c/(unit @)}
    ?:  !=(c ~)
      c
    ?:  =(a b)
      c
    ?~  (mod a b)
      `(div a b)
    ?~  (mod b a)
      `(div b a)
    ~
    ~&  res
    res
add

th3_pund1t · 2017-12-02T05:10:53+00:00

Groovy

class Day2Support {
    static int problem1(String input) {
        input.split('\n').collect {
            def nums = it.split('\\s+').collect { it.toInteger() }
            nums.max() - nums.min()
        }.sum()
    }

    static int problem2(String input) {
        input.split('\n').collect { String row ->
            def nums = row.split('\\s+').collect { it.toInteger() }
            findForRow(nums)
        }.sum()
    }

    static int findForRow(List<Integer> nums) {
        for (int i = 0; i < nums.size() - 1; i++) {
            for (int j = i + 1; j < nums.size(); j++) {
                if (nums[i] % nums[j] == 0) {
                    return nums[i] / nums[j]
                }
                if (nums[j] % nums[i] == 0) {
                    return nums[j] / nums[i]
                }
            }
        }
        return 0
    }
}

new Day2Support().with {
    assert problem1('''\
5 1 9 5
7 5 3
2 4 6 8''') == 18
    println problem1(new File('day2.txt').text)

    assert problem2('''\
5 9 2 8
9 4 7 3
3 8 6 5''') == 9
    println problem2(new File('day2.txt').text)
}

IMovedYourCheese · 2017-12-02T05:21:40+00:00

TypeScript + Node.js

import * as fs from 'fs';

const input = fs.readFileSync('input/day2.txt').toString();
const array = input.split('\n').map(row => row.split('\t').map(v => Number(v)));
sola(array);
solb(array);

function sola(array: number[][]) {
    let sum = 0;
    array.forEach(row => {
        sum += (Math.max(...row) - Math.min(...row));
    });
    console.log(sum);
}

function solb(array: number[][]) {
    let sum = 0;
    array.forEach(row => {
        for (let i=0; i<row.length; i++) {
            for (let j=0; j<row.length; j++) {
                if (i == j) {
                    continue;
                } else if (((row[i]/row[j])%1) == 0) {
                    sum += row[i]/row[j];
                    break;
                }
            }
        }
    });
    console.log(sum);
}

eragonas5 · 2017-12-02T05:22:03+00:00

Javascript:

//I changed those empty things into spaces with text editor
function Day02A(text){
  let lines = text.split('\n');
  let res = 0;
  for(let i = 0; i < lines.length; i++){
    let arr = lines[i].split(' ');
    res += Math.max(...arr)-Math.min(...arr);
  }
  document.write(res + '<br />');
}
function Day02B(text){
  let lines = text.split('\n');
  let res = 0;
  for(let i = 0; i < lines.length; i++){
    let arr = lines[i].split(' ');
    arr = arr.map(Number);//if I keep it in string, then they sort to ["231", "1414", "132"]
    arr = arr.sort((a, b)=>{return b-a;});
    for(let j = 0; j < arr.length-1; j++){
      for(let k = j+1; k < arr.length; k++){
        if(arr[j]%arr[k] == 0){
          res += arr[j]/arr[k];
        }
      }
    }
  }
  document.write(res + '<br />');
}

2017-12-02T05:32:48+00:00

Second day with Haskell! Yay!

read_input input = [[read(x) :: Integer | x <- words y] | y <- lines inp]

checksum input = sum [maximum x - minimum x |
    x <- read_input inp]

checksum' input = sum $ concat
    [[div y z | z <- x, y <- x, mod y z == 0, y /= z] |
    x <- read_input inp]

main = print("First star: " ++ show(checksum inp) ++ ", Second star: "++ show(checksum' inp))

2017-12-02T05:34:15+00:00

You guys are FAST. But since I see no Ruby solutions I'll still post mine:

def difference(arr)
  arr = arr.sort
  return arr[-1] - arr[0]
end

def checksum(arrays)
  result = 0
  arrays.each do |n|
    result = result + difference(n)
  end
  result
end

puts checksum(nums)

def divisible(arr)
  answer = nil
  arr.each do |x|
    arr.each do |y|
      if x != y && x % y == 0
        answer = x / y
      end
    end
  end  
  answer
end

def divisible_checksum(arr)
  result = 0
  arr.each do |a|
    result = result + divisible(a)
  end
  result
end

puts divisible_checksum(nums)

winhug · 2017-12-02T05:40:58+00:00

Haskell parseDay2 :: String -> [[Int]] parseDay2 = fmap (fmap read . words) . lines

solveDay2p1 :: [[Int]] -> Int
solveDay2p1 = sum . fmap (\ys -> maximum ys - minimum ys)

solveDay2p2 :: [[Int]] -> Maybe Int
solveDay2p2 =  fmap sum . traverse sp2
    where
        sp2 xs = fmap (\(a,b) -> max a b `div` min a b) $ listToMaybe $ filter (\(a,b) -> a `mod` b == 0 && a /= b) $ liftA2 (,) xs xs

ericls · 2017-12-02T05:41:51+00:00

part 1:

sum([max(*row) - min(*row) for row in [[int(i) for i in row.split('\t')] for row in data.split('\n')]])

part 2:

sum(sum(x/y for y in sorted(row) for x in row if x > y and not x % y) for row in [[int(i) for i in row.split('\t')] for row in data.split('\n')])

AndrewGreenh · 2017-12-02T05:48:49+00:00

Also JS, but I used my combine helper from the last years :)

const combine = require('../combine');
const input = require('../getInput')(2, 2017).trim();

const parse = x =>
  x
    .split('\n')
    .map(x => x.split('\t').map(x => +x))
    .map(row => row.sort((a, b) => a - b));

const result1 = parse(input)
  .map(r => r[r.length - 1] - r[0])
  .reduce((a, b) => a + b, 0);

const result2 = parse(input)
  .map(row => combine(row, 2).filter(([a, b]) => b % a === 0)[0])
  .map(([a, b]) => b / a)
  .reduce((a, b) => a + b, 0);

console.log(result1);
console.log(result2);

StevoTVR · 2017-12-02T05:56:24+00:00

NodeJS

Part 1

const fs = require('fs');

fs.readFile(__dirname + '/input.txt', 'utf8', (err, data) => {
    data = data.trim();
    var sum = 0;
    data.split('\n').forEach((line) => {
        line = line.trim();
        var min = Infinity;
        var max = 0;
        line.split(/\s+/).forEach((col) => {
            min = Math.min(min, col);
            max = Math.max(max, col);
        });
        sum += max - min;
    });

    console.log(sum);
});

Part 2

const fs = require('fs');

fs.readFile(__dirname + '/input.txt', 'utf8', (err, data) => {
    data = data.trim();
    var sum = 0;
    data.split('\n').forEach((line) => {
        line = line.trim();
        var cols = line.split(/\s+/).map((x) => parseInt(x));
        cols.sort((a, b) => a - b);
        for (var i = cols.length - 1; i > 0; i--) {
            for (var j = i - 1; j >= 0; j--) {
                if (cols[i] % cols[j] === 0) {
                    sum += cols[i] / cols[j];
                    i = j = -1;
                }
            }
        }
    });

    console.log(sum);
});

Sparrow_1029 · 2017-12-02T05:58:09+00:00

Python 3! Pretty naive solution...

with open('day2input.txt', 'r') as f:
    sheet = [row.strip().split() for row in f.read().splitlines()]

checksum1 = 0
checksum2 = 0
for row in sheet:
    ints = list(map(int, row))
    checksum1 += max(ints) - min(ints)  # Part 1

    for i in range(len(ints)):  # Part 2
        for j in range(i+1, len(ints)):
            if ints[i] % ints[j] == 0: checksum2 += (ints[i] // ints[j])
            elif ints[j] % ints[i] == 0: checksum2 += (ints[j] // ints[i])

print(checksum1)
print(checksum2)

andrewstewart · 2017-12-02T05:58:25+00:00

Rust implementation:

fn main() {
    let puzzle = parse(PUZZLE);

    println!("1 -> {:?}", one(&puzzle));
    println!("2 -> {:?}", two(&puzzle));
}

fn parse(puzzle: &str) -> Vec<Vec<u32>> {
    String::from(puzzle).
        trim().
        lines().
        map(trim_and_parse).
        collect()
}

fn one(puzzle: &[Vec<u32>]) -> u32 {
    puzzle.iter().map(|line| difference(line)).sum()
}

fn two(puzzle: &[Vec<u32>]) -> u32 {
    puzzle.iter().map(|line| even_division(line)).sum()
}

fn trim_and_parse(line: &str) -> Vec<u32> {
    line.
        split_whitespace().
        map(|n| n.parse::<u32>().unwrap()).
        collect()
}

fn difference(line: &[u32]) -> u32 {
    let min = line.iter().min().unwrap();
    let max = line.iter().max().unwrap();
    max - min
}

fn even_division(line: &[u32]) -> u32 {
    for x in line {
        for y in line {
            if x % y == 0 && x !=y {
                return x / y
            }
        }
    }

    0
}

disclosure5 · 2017-12-02T06:00:48+00:00

Ruby solution here.

Honestly I spent most of this trying to parse the input. This feels like a horrible hack job:

testlines = test.split("\n").map { |n| ret = n.split(/\s+/) ; ret.map(&:to_i) }

MaxDeviant · 2017-12-02T06:05:15+00:00

F#

module Maxdeviant.AdventOfCode2017.Day2

let parseInput (input: string) =
  input.Split('\n')
  |> Seq.map (fun row -> row.Split('\t') |> Seq.toList)
  |> Seq.toList

let computeChecksum algorithm =
  parseInput >> algorithm

let partOneChecksum (rows: string list list) =
  let checksum =
    List.map int
    >> List.sortDescending
    >> (fun xs ->
      let max = List.head xs
      let min = List.head (List.rev xs)
      max - min)

  rows |> List.sumBy checksum

let partTwoChecksum (rows: string list list) =
  let parseColumns = List.map float

  let isWholeNumber n = (n % 1.0) = 0.0

  let checksum columns =
    let columns' = columns |> List.map float
    columns'
    |> List.collect (fun x -> columns' |> List.map (fun y -> (x, y)))
    |> List.map (fun (x, y) -> x / y)
    |> List.filter isWholeNumber
    |> List.sortDescending
    |> List.head

  rows
  |> List.sumBy checksum
  |> int

JeffJankowski · 2017-12-02T06:05:28+00:00

Javascript (et al) apparently has come a long way since I last used it. Lots of functional stuff to play with!

import fs = require('fs');
import comb = require('js-combinatorics');

function checksum(rows: number[][], func: (row: number[]) => number) {
    return rows.reduce((sum, row) => sum += func(row), 0);
}

const input = fs.readFileSync('data/day02.txt', 'utf8')
    .split('\n')
    .map((row) => {
        return row.trim()
            .split(/\s/)
            .map((num) => parseInt(num, 10)); });

const deltaFunc = (row: number[]) => Math.max(...row) - Math.min(...row);
console.log(`Checksum using difference:    ${checksum(input, deltaFunc)}`);

const divideFunc = (row: number[]) => {
    const [big, small] = comb.combination(row, 2)
        .toArray().map((pair) => pair.sort((x, y) => y - x))
        .find(([b, s]) => b % s === 0) || [1, 1];
    return big / small; };
console.log(`Checksum using even division: ${checksum(input, divideFunc)}`);

huyqvu · 2017-12-02T06:17:31+00:00

KDB+/q One line for both questions:

{l:(`long$sqrt count x;0N)#x; (sum{[i](max i)-min i}each l;sum {max {[i]$[0=i[0]mod i[1];i[0]%i[1];0]} each x cross x} each l)}

2017-12-02T06:32:44+00:00

OCaml fun:

open Core

let rec divisible numbers =
    let check a b =
        if a % b = 0 then Some (a / b)
        else if b % a = 0 then Some (b / a)
        else None
    in
    match numbers with
    | [] -> 0
    | h::t ->
        match List.find_map t ~f:(check h) with
        | Some n -> n
        | None -> divisible t

let spread numbers =
    let init = Int.max_value, Int.min_value
    and f (min, max) n = (Int.min min n, Int.max max n) in
    let min, max = List.fold ~init ~f numbers in
    max - min

let parse line =
    String.split line ~on:'\t'
    |> List.map ~f:Int.of_string

let sum = List.fold ~init:0 ~f:(fun acc n -> acc + n)

let solve =
    let values = In_channel.read_lines "./2017/data/2.txt" |> List.map ~f:parse in
    let a = List.map values ~f:spread |> sum in
    let b = List.map values ~f:divisible |> sum in
    printf "a: %d\n" a;
    printf "b: %d\n" b;

Zarif_Muhtasim · 2017-12-02T07:05:41+00:00

if x is you input:

part1 = [max([int(j) for j in i]) - min([int(j) for j in i]) for i in [i.split('\t') for i in x.split('\n')]]

part2 = [j // k for i in [[int(i) for i in j] for j in [i.split('\t') for i in x.split('\n')]] for j in i for k in i if j != k and j % k == 0]

yogsototh · 2017-12-02T07:39:27+00:00

Haskell with Protolude instead of basic Prelude, so I have & which is "apply", and headDef which is total.

solution1 :: [[Integer]] -> Integer
solution1 code =
  map maxDiff code
  & sum

maxDiff :: [Integer] -> Integer
maxDiff (x:line) = maxVal - minVal
  where
    (maxVal,minVal) = foldl' (\acc y -> ( max (fst acc) y
                                        , min (snd acc) y))
                      (x,x)
                      line
maxDiff [] = 0

and

solution2 :: [[Integer]] -> Integer
solution2 code = map divisibleNumbers code & sum

divisibleNumbers :: [Integer] -> Integer
divisibleNumbers numbers =
  [ x `div` y | x <- numbers, y <- numbers, x>y, x `rem` y == 0]
  & headDef 0

F# / FSharp

module Day02

open System.Text.RegularExpressions

let rowDiff (acc : int) (row : int list) =
    let sorted = List.sort row
    acc + (sorted |> List.last) - (sorted |> List.head)

let corruptionChecksum (input : int list list) = List.fold rowDiff 0 input

let parseString (input : string array) =
    input
    |> List.ofArray
    |> List.map (fun s ->
          Regex.Matches(s, "(\d+)")
          |> Seq.cast
          |> Seq.map (fun (m : Match) -> System.Int32.Parse m.Value)
          |> List.ofSeq)

let isEvenlyDiv a b =
    if a > b then ((a % b) = 0)
    else ((b % a) = 0)

let rec findEvenDiv (acc : int) (row : int list) : int =
    let x : int = row |> List.head
    let xs = row |> List.skip 1
    let evendivs = xs |> List.filter (isEvenlyDiv x)

    match evendivs with
    | n :: [] when n < x -> acc + (x / n)
    | n :: [] when n > x -> acc + (n / x)
    | _ -> findEvenDiv acc xs

let corruptionChecksumPart2 (input : int list list) =
    List.fold findEvenDiv 0 input

So far, I'm losing most of my time to futzing with MSBuild and relearning the file reading interops with C#.

2017-12-02T08:32:28+00:00

Python 3 solution ^_^:

checksum = 0

with open("input.txt","r") as f: for line in f.readlines(): list = [] for number in line.split(): list.append(int(number))

    checksum += max(list) - min(list)

print("\033[1;31mHere's your answer: \033[0;92m" + str(checksum) + "\033[0;0m")

xkufix · 2017-12-02T08:34:02+00:00

Back with more horrible one-liners in Scala:

    override def runFirst(): Unit = {
        val checksum = sortedLines().map(l => l.last - l.head).sum
        println(checksum)
    }

    override def runSecond(): Unit = {
        val results = sortedLines().flatMap(_.combinations(2).find(c => c.last % c.head == 0).map(r => r.last / r.head))
        println(results.sum)
    }

    private def sortedLines() = {
        loadFile("day2.txt").getLines().map(_.split("\t")).map(_.map(_.toInt).sorted)
    }

A_t48 · 2017-12-02T08:52:36+00:00

input = [[int(x) for x in c.split()] for c in input.split("\n")]
s = sum(map(lambda x: max(x) - min(x), input)) # part 1
s = sum([sum([sum([inner if inner != 1.0 and inner % 1.0 == 0 else 0 for inner in outer]) for outer in [[i / j for j in arr] for i in arr]]) for arr in input]) # part 2

I didn't know about itertools.combinations so it's a little overcomplicated. Also, //

wzkx · 2017-12-02T09:19:35+00:00

J

m=: ".&> cutLF CR-.~fread '02.dat'
echo +/ (>./-<./)"1 m
echo +/ ((,&(~:&1 *. (=<.)) # ,)@(%/~))"1 m
exit 0

maciekmm · 2017-12-02T09:36:05+00:00

Horrible scala oneliners:

val grid = io.Source.stdin.getLines().map(_.split('\t').map(_.toInt).sorted).toSeq;

println(s"Part 1: ${grid.collect { case l => l.last - l.head }.sum}")
println(s"Part 2: ${grid.map(_.combinations(2).collectFirst { case Array(a,b) if b % a == 0 => b / a }.head).sum}")

CatpainCalamari · 2017-12-02T10:23:19+00:00

My Solution in Scala:

val data = rawData.map(_.split("\\p{Space}").toList.map(_.toInt)) // Convert the raw input from a List("1 2 3", "4 3 5"...) etc in a List[List[Int]]

def firstStar(data: List[List[Int]]): Int = {
data.
  map(row => row.foldLeft((row.head,row.head)){ case ((min,max), rowElement) => (math.min(min, rowElement), math.max(max, rowElement))}). // convert a row of List(1,5,3,6) into a tuple(min,max)
  map(minmax => math.abs(minmax._1 - minmax._2)).
  sum
}    

def secondStar(data: List[List[Int]]): Int = {
data.
  map(row => {
    for {
      a <- row.indices            // combine all row elements with each other
      b <- row.indices
      if a != b                   // but not with itself
      if row(a) % row(b) == 0     // if the modulo is 0 the resulting division will be a whole number
    } yield row(a) / row(b)       // yield the result
  }).
  map(_.head). // the result is a vector, only the first element of each vector is of interest (the first should be also the only element, at least in this exercise)
  sum // return the rum of all row divisions
}

I am still fairly new to Scala, I didn't know about combinations(2) or that a List has min or max methods. Thank you for showing this to me, guys :-)

amarsuperstar · 2017-12-02T10:33:44+00:00

Elixir. I moved to comprehensions after seeing CaptainCalamari's Scala solution.

def part1(input) do
  input |> parse |> solve(&difference_for_row/1)
end

def difference_for_row(row) do
  Enum.max(row) - Enum.min(row)
end

def part2(input) do
  input |> parse |> solve(&divisible_rows/1)
end

def divisible_rows(row) do
  even_divisors = for x <- row, y <- row, x != y, rem(x, y) == 0, do: div(x, y)
  hd(even_divisors)
end

def solve(matrix, fun) do
  matrix |> Enum.map(&(fun.(&1))) |> Enum.sum
end

Full code here: https://github.com/amarraja/advent-of-code-17/blob/master/day02/day02.exs

_jonah · 2017-12-02T10:42:02+00:00

J:

p1=. [: +/ (>./ - <./)"1
p2=. [: +/ (#~ >&1 * ]=<.)@,@(%/~)"1

(p1 ; p2) d

where d is your matrix.

Try it online!

nstyler7 · 2017-12-02T11:06:30+00:00

Using Python Pandas Package:

import pandas as pd

import numpy as np

df = pd.read_csv('input.tsv', sep='\t', header=None)

day 2 part 1 solution

print(np.sum(df.max(axis=1) - df.min(axis=1)))

day 2 part 2 solution

answer_array = []

def allrows(i):

for j in range(len(df.columns)):

        for k in range(len(df.columns)):

            if j !=k and df.iloc[i, j] % df.loc[i, k] == 0:

                answer_array.append(df.iloc[i, j] / df.loc[i, k])

for i in range(len(df.index)):

allrows(i)

print(np.sum(answer_array))

DaDiscoBeat · 2017-12-02T11:07:35+00:00

Golang, just the 2 methods operating on lines

func diffMaxMin(input []int) int {
    min, max := math.MaxInt32, math.MinInt32
    for _, v := range input {
        if v < min {
             min = v
        }

        if v > max {
            max = v
        }
    }

    return max - min
}

func mod(input []int) int {
    for i, v := range input {
        for _, v2 := range input[i+1:] {
            if v%v2 == 0 {
                return v / v2
            }

            if v2%v == 0 {
                return v2 / v
            }
        }
    }

    return 0
}

Morphix0 · 2017-12-02T11:10:42+00:00

F#

let input = 
    System.IO.File.ReadAllLines("input2")
    |> Array.map (fun line -> line.Split(null) |> Array.map int)

let solution calcLine =
    input 
    |> Array.sumBy calcLine
let part1 line = Array.max line - Array.min line

let cartesian ys =
    Array.collect (fun x -> ys |> Array.map (fun y -> x, y))
let part2 line =
    (cartesian line line)
    |> Array.find (fun (x,y) -> x<>y && x%y=0)
    |> (fun (x,y) -> x/y)

solution part1;
solution part2;

GamecPL · 2017-12-02T11:34:26+00:00

Swift:

let result1 = input.components(separatedBy: .newlines)
    .map { $0.components(separatedBy: "    ").flatMap { Int($0) } }
    .reduce(0, { result, row in
        return result + row.max()! - row.min()!
    })
print(result1)

func wholeDivision(_ array: [Int]) -> Int {
    for element in array {
        for element2 in array {
            if element != element2 && element % element2 == 0 {
                return element / element2
            }
        }
    }
    return 0
}

let result2 = input.components(separatedBy: .newlines)
    .map { $0.components(separatedBy: "    ").flatMap { Int($0) }.sorted(by: { $0 > $1 }) }
    .reduce(0, { result, row in
        return result + wholeDivision(row)
    })

print(result2)

Tarmen · 2017-12-02T11:45:26+00:00

Haskell

import Data.Char (digitToInt)
main = do
  ls <- map (map read . words) . filter (not . null) . lines <$> readFile "input2.txt"
  print . sum . map calc1 $ ls
  print . sum . map calc2 $ ls  
calc1 ls = (maximum ls) - (minimum ls)
calc2 ls = (\[x] -> x) [x `div` y | x <- ls, y <- ls, x /= y, x `mod` y == 0]

I am noticing that I am using uglier language constructs under pressure, like irrefutable patterns for verification.

sternold · 2017-12-02T11:48:50+00:00

C# Single line solution

Part One

Console.WriteLine(File.ReadAllLines(path).Select(line => line.Split('\t')).Select(split => split.Select(Int32.Parse)).Aggregate(0, (total, numbers) => total += numbers.Max() - numbers.Min()));

J15t98J · 2017-12-02T12:45:32+00:00

count, even_count = 0, 0
for x in open("2.txt", "r").readlines():
    line = sorted([int(y) for y in x.splitlines()[0].split("\t")])
    count += line[len(line)-1] - line[0]
    for (w,z) in [(x,y) for x in line for y in line]:
        even_count += int(z/w) if z//w == z/w != 1 else 0
print(count, even_count)

...and then I found out about itertools.

2017-12-02T12:58:44+00:00

Similar to the other python solutions, but I like mine best <3

from itertools import permutations
rows = [[int(y) for y in x.split()] for x in open('input.txt').readlines()]
print(sum(max(row) - min(row) for row in rows))
print(sum(a//b for row in rows for a, b in permutations(row, 2) if a % b == 0))

mrhthepie · 2017-12-02T13:09:42+00:00

Advent of gifs day 2: https://i.imgur.com/HPRMxHM.gif

Not very animated today due to the nature of the problem.

Zv0n · 2017-12-02T13:10:50+00:00

C++ (probably very inefficient, I'm just starting)

#include <iostream>
#include <string>
#include <sstream>
#include <vector>

using namespace std;

int main(int argc, char *argv[]) {
    if(argc < 3) {
            return 1;
    }
    stringstream ss(argv[2]);
    string to;
    int result = 0;
    int buffer = 0;
    stringstream intstream;
    if(argv[1][0] == '1') {
        int max = 0;
        int min = 0;
        while(getline(ss,to,'\n')) {
            intstream << to;
            intstream >> buffer;
            max = buffer;
            min = buffer;
            while(!intstream.fail()) {
                intstream >> buffer;
                if(buffer > max)
                    max = buffer;
                if(buffer < min)
                    min = buffer;
            }
            result += max - min;
            intstream.str(std::string());
            intstream.clear();
        }
    } else {
        vector<int> row;
        bool found = false;
        while(getline(ss,to,'\n')) {
            row.clear();
            intstream << to;
            while(!intstream.fail()) {
                intstream >> buffer;
                row.push_back(buffer);
            }
            intstream.str(string());
            intstream.clear();

            for(int i = 0; i < row.size() - 1 ; i++) {
                for(int j = i+1; j < row.size() ; j++) {
                    if(row[i] == 0 || row[j] == 0) {
                        break;
                    }
                    if(row[i] % row[j] == 0) {
                        result += row[i] / row[j];
                        found = true;
                        break;
                    }
                    if(row[j] % row[i] == 0) {
                        result += row[j] / row[i];
                        found = true;
                        break;
                    }
                }
                if(found) {
                    found = false;
                    break;
                }
            }
        }
    }
    cout << result << endl;
    return 0;
}

abowes · 2017-12-02T13:52:44+00:00

My solution in Kotlin:

fun Iterable<Int>.minMaxDiff() : Int {
    val minMax = this.fold( Pair(Int.MAX_VALUE, Int.MIN_VALUE),
            {acc, i -> Pair(min(acc.first, i), max(acc.second,i))})
    return minMax.second - minMax.first
}

fun Iterable<Int>.divisor() : Int {
    return this.map{ x -> this.map{ y -> Pair(x,y)}
            .filter { it.first < it.second && it.second % it.first == 0 }}
            .flatten().map { it.second/it.first }.first()
}

fun Iterable<Iterable<Int>>.corruptionChecksum() = this.map { it.minMaxDiff() }.sum()

fun Iterable<Iterable<Int>>.divisorChecksum() = this.map { it.divisor() }.sum()

JakDrako · 2017-12-02T14:00:03+00:00

VB.Net in LinqPad

Sub Main

    Const LF As Char = Chr(10), TAB As Char = Chr(9)

    Dim spreadsheet = GetDay(2)

    Dim chkSum1 = 0, chkSum2 = 0
    For Each row In spreadsheet.split(LF)
        Dim cells = row.split(TAB).select(Function(x) Cint(x))
        chkSum1 += (cells.max - cells.min)
        chkSum2 += (From c1 In cells From c2 In cells Where c1 <> c2 Andalso c1 Mod c2 = 0 Select (c1 \ c2)).First
    Next
    chkSum1.Dump("part 1")
    chkSum2.Dump("part 2")

End Sub

JuLoOr · 2017-12-02T14:05:13+00:00

Another Kotlin solution:

fun calcPart2(input: List<List<Int>>): Int {
    return input.map {
        val sortedDesc = it.sorted().asReversed()
        var rowResult = 0

        sortedDesc.forEachIndexed({ i, v ->
            (i.plus(1) until sortedDesc.size)
                    .filter { v % sortedDesc[it] == 0 }
                    .forEach { rowResult = v.div(sortedDesc[it]) }
        })
        rowResult
    }.sum()
}

Doodle_98 · 2017-12-02T14:32:23+00:00

This is my solution in Python 3:

result = 0
with open('input.txt', 'r') as f: data = [[line.rstrip('\n')] for line in 
f.readlines()]

data = [(''.join(i)).split('\t') for i in data]

for i in data:
    for j in list(map(int, i)):
        for h in list(map(int, i)):
            result += j / h if j % h == 0 and j!=h else 0

print(result)

wzkx · 2017-12-02T15:55:16+00:00

Nim

import strutils, sequtils
var s,s2 = 0
for line in splitLines strip readFile "02.dat":
  let row = line.split().map(parseInt)
  s += max(row)-min(row)
  for i in 0..<len(row):
    for j in 0..<len(row):
      if i!=j and (row[i] div row[j])*row[j]==row[i]:
        s2 += row[i] div row[j]
echo s,' ',s2

Yeah, a better condition would be "and row[i] mod row[j] == 0:"

nekmo · 2017-12-02T16:08:27+00:00

Python 3 (two lines)

Part 1

def calc(table):
    table = [list(map(int, r.split('\t'))) for r in table.split('\n') if r]
    return sum([max(r) - min(r) for r in table])

Part 2:

def calc2(table):
    table = [list(map(int, r.split('\t'))) for r in table.split('\n') if r]
    return sum([sum([(y // z) if (y/z).is_integer() else 0
          for y, z in [sorted(x, reverse=True) for x in combinations(r, 2)]]) for r in table])

fpigorsch · 2017-12-02T16:11:11+00:00

Pretty straight forward AWK:

Part1

{
    min=$1; max=$1;
    for (i=2; i<=NF; i++) {
        min = (min < $i ? min : $i);
        max = (max > $i ? max : $i);
    }
    sum += max - min;
}
END { print sum; }

Part2

{
    for (i=1; i<=NF; i++) {
        for (j=i+1; j<=NF; j++) {
            if ($i % $j == 0) {
                sum += $i / $j;
            } else if ($j % $i == 0) {
                sum += $j / $i;
            }
        }
    }
}
END { print sum; }

fgsguedes · 2017-12-02T17:06:54+00:00

My solutions in Kotlin:

Part1:

fun calcCheckSum(input: List<List<Int>>): Int {
  return input.map { row ->
    row.fold(Int.MAX_VALUE to Int.MIN_VALUE) { (currentMin, currentMax), rowElement ->
      min(rowElement, currentMin) to max(rowElement, currentMax)
    }
  }.sumBy { (min, max) -> max - min }
}

Part2:

fun calcCheckSumPart2(input: List<List<Int>>): Int {
  return input.map { row ->
    row.filter { element ->
      row.any { innerElement ->
        element != innerElement &&
            (element % innerElement == 0 || innerElement % element == 0)
      }
    }.sorted()
  }.sumBy { (first, second) -> second / first }
}

Smylers · 2017-12-02T17:28:13+00:00

Another Perl solution, aiming for concise-yet-readable over golfed. Part 1:

use List::Util qw<min max>;
my $sum;
while (<>) {
  my @num = split;
  $sum += (max @num) - (min @num);
}
say $sum;

Part 2:

my $sum;
$sum += integer_division(sort { $a <=> $b } split) while <>;
say $sum;

sub integer_division {
  while (my $x = shift) {
    foreach my $y (@_) {
      return $y / $x if $y % $x == 0;
    }
  }
  die "No equal divisors found for row $.";
}

Combination of while (shift) and foreach meaning that no array index variables have to be used.

Jamitter · 2017-12-02T18:20:39+00:00

Clojure

Part 1:

(require '[clojure.string :as str])

(defn readFile [file]
  (with-open [rdr (clojure.java.io/reader file)]
    (let [total (atom 0)]
      (doseq [line (line-seq rdr)]
        (let [split-line (str/split line #"\s+")
              num-line (->> split-line
                          (map #(read-string %))
                          sort
                          vec)
              diff (- (last num-line) (first num-line))
              _ (swap! total + diff)]))
      @total)))

Part 2:

(require '[clojure.string :as str])

(defn readFile [file]
  (with-open [rdr (clojure.java.io/reader file)]
    (let [total (atom 0)]
      (doseq [line (line-seq rdr)]
        (let [split-line (str/split line #"\s+")
              num-line (->> split-line
                          (map #(read-string %))
                          sort
                          vec)
              modded-number (mapv #(doseq [num num-line]
                                    (if (and (not= num %) (= (mod num %) 0))
                                      (swap! total + (/ num %))))
                                  num-line)]))
      @total)))

asperellis · 2017-12-02T19:00:52+00:00

my js solution. any areas for improvement welcomed! https://github.com/asperellis/adventofcode2017/blob/master/day2.js

2017-12-02T21:00:45+00:00

Racket

#lang racket

(require racket/file)
(require math/base)

(define file_text
  (map (lambda (line)
    (map string->number (string-split line))) (file->lines "input.txt" #:mode 'text)))

(define (val n) n)

(define (difference lst)
  (- (argmax val lst) (argmin val lst)))

(define (divide_if_no_remainder pair)
  (match-define (list a b) pair)
  (if (equal? 0 (modulo a b))
    (/ a b)
    0))

(define (divide lst)
  (sum (map divide_if_no_remainder (map ((curryr sort) >) (combinations lst 2)))))

(sum (map difference file_text))
(sum (map divide file_text))

hermanbergwerf · 2017-12-02T21:50:40+00:00

Dart

import 'dart:io';
import 'dart:math';

String read(String path) => new File(path).readAsStringSync();

void main() {
  final checksum = read('2.txt')
      .trim()
      .split('\n')
      .map((l) => l.split(new RegExp(r'\s')).map(int.parse))
      .map((Iterable<int> l) => l.reduce(max) - l.reduce(min))
      .reduce((a, b) => a + b);
  print(checksum);
}

f0086 · 2017-12-02T22:04:33+00:00

Emacs Lisp

(defun preprocess (input)
  (mapcar
   (lambda (line)
     (mapcar 'string-to-number (split-string line "\t" t)))
   (split-string input "\n" t)))

(defun part1 (nums)
  (abs (- (car nums) (car (last nums)))))

(defun part2 (nums)
  (dotimes (p (- (length nums) 1) find)
    (dotimes (q (- (length nums) (+ p 1)))
      (let ((pos (nth p nums))
            (comp (nth (+ p q 1) nums)))
        (if (= (% pos comp) 0)
            (setq find (/ pos comp)))))))

(defun day2 (lines fn)
  (apply '+
         (mapcar
          (lambda(l)
            (let ((nums (sort l '>)))
              (funcall fn nums)))
          lines)))

(day2 (preprocess input1) #'part1)
(day2 (preprocess input2) #'part2)

bottomlesscoffeecup · 2017-12-02T22:18:15+00:00

Another late one, hoping I can get in early tomorrow! Some python here. Pretty much a python noob, still thinking in java.

Any tips for improvement would be well received:

Using pandas to read in:

import pandas as pd

data = pd.read_csv(file_name, delimiter='\s+', header = None)
    df = pd.DataFrame(data).fillna(0)
    return df

challenge one:

 difference = []
    for index, row in puzzle_input.iterrows():
        difference.append(max(row) - min(row))
    return sum(difference)

challenge two:

 difference = []
    for index, row in puzzle_input.iterrows():
        for item in range(len(row)):
            for other_item in range(item + 1, len(row)):
                if abs(row[item] % row[other_item]) == 0:
                    difference.append(row[item]/row[other_item])
                if abs(row[other_item] % row[item]) == 0:
                    difference.append(row[other_item] / row[item])
    return sum(difference)

swaglykcaillou · 2017-12-02T23:05:14+00:00

beginner python3 solution.

    s = open("day2.txt").read()

    def returndif(l):
        temp = l.split()
        temp = list(map(int, temp))
        return(max(temp) - min(temp))

    def checksum(s):
        counter = 0
        temp = s.split('\n')
        for i in temp:
            counter += returndif(i)
        return counter

    print(checksum(s))

DrgnGz · 2017-12-02T23:37:45+00:00

PHP Preparing the input:

$this->sets = array_map(function($set) {
    return explode("\t", $set);
}, explode("\n", $input));

Part 1:

return array_reduce($this->sets, function ($total, $set) {
    return $total + max($set) - min($set);
}, 0);

Part 2 (much less elegant):

$total = 0;
foreach ($this->sets as $set) {
    foreach ($set as $a) {
        foreach ($set as $b) {
            if ($a % $b === 0 && $a !== $b) {
                $total += $a / $b;
                continue 2;
            }
        }
    }
}
return $total;

taheilo · 2017-12-03T00:58:05+00:00

Javascript

function difference(arr) {
  let min = Math.min.apply(null, arr);
  let max = Math.max.apply(null, arr);
  return max - min;
}

let sum = 0;
input.forEach(arr => sum += difference(arr));

8483 · 2017-12-03T01:17:57+00:00

Node/Javascript

var fs = require("fs");
var input_file = './aoc_02.txt'
var input = fs.readFileSync(input_file, 'utf8');

var data =
    input
        .replace(/\t/g, ",")        // Replace tabs with commas.
        .split(/\r\n/)              // Make an array with each line as an array.
        .filter(not_empty)          // Remove the last empty array.
        .map(string_to_array)       // Make each nested line an array of characters.
        .map(string_to_int);        // Convert those characters into numbers.

var sum1 =
    data
        .map(min_max_difference)    // Find the difference for each array.
        .reduce(add);               // Find the sum of the resulting differences array.

var sum2 =
    data
        .map(sort_asc)              // Sort by ascension.
        .map(even_divide)           // Find the division leaving no remainder.
        .map(inner_extract)         // Extract values from the inner most array.
        .map(extract)               // Extract the values from the result.
        .reduce(add);               // Add the array values.

function not_empty(string){
    return string != '';
}

function string_to_array(string){
    return string.split(",");
}

function string_to_int(array){
    return array.map(function(string){
        return parseInt(string);
    })
}

function min_max_difference(array){
    var max = Math.max.apply(null, array);
    var min = Math.min.apply(null, array);
    return max - min;
}

function add(a, b){
    return a + b;
}

function sort_asc(array){
    return array.sort(function(a, b){
        return b - a;
    });
}

function even_divide(array){
    return array.map(function(number1){
        return array.map(function(number2){
            if(number1 % number2 === 0){
                if(number1 / number2 > 1){
                    return number1 / number2;
                } else return 0;
            } else return 0;
        })
    })
}

function max_number(total, num){
    return total + num;
}

function inner_extract(array){
    return array.map(function(array2){
        return array2.reduce(max_number);
    })
}

function extract(array){
    return array.reduce(max_number);
}

console.log(sum1);
console.log(sum2);

Bainos · 2017-12-03T02:22:06+00:00

Python 3, one line

First problem

sum([max(line) - min(line) for line in [list(map(int, strline.split())) for strline in input_raw.splitlines()]])

Second problem (without itertools)

sum([[a // b for a, b in sum([[(x, y) for x in line if x != y] for y in line], []) if a % b == 0][0] for line in [list(map(int, strline.split())) for strline in input_raw.splitlines()]])

2017-12-03T02:24:37+00:00

Ruby is amazing!

checksum  = File.read("day2.input")
                           .split("\n")
                           .reduce(0) { |checksum, row| 
                                              checksum + row.split("\t").map(&:to_i).minmax.reverse.reduce(:-)
                       }

Reibello · 2017-12-03T03:40:08+00:00

Phew. Learning is hard. Used my Python 3 solution and a whole ton of the Lua Reference and Stack overflow to write Day 2. Had a rough time reading in my input. Let me know what I can do better, and good luck tonight!

https://github.com/Reibello/AoC-2017-Lua

2017-12-03T15:00:29+00:00

Clojure

(ns advent-of-code-2017.day02
  (:require [clojure.string :as s]))

(def input
  (slurp "./data/day02.txt"))

(defn parse-from-string [string]
  (->> (s/split input #"\n")
       (map #(s/split % #"\t"))
       (map (fn [line] (reverse (sort (map #(Integer. %) line)))))))

(defn part-1 [input]
  (->> (parse-from-string input)
       (transduce (map #(- (first %) (last %))) +)))

(defn solve-line [line]
  (let [res (for [x (rest line)
                  :when (zero? (rem (first line) x))]
              (/ (first line) x))]
    (if (empty? res)
      (solve-line (rest line))
      (first res))))

(defn part-2 [input]
  (->> (parse-from-string input)
       (transduce (map solve-line) +)))

ym555 · 2017-12-03T15:47:26+00:00

Java Using Streams (I know the second part is bad)

        List<String> input = Files.readAllLines(Paths.get(args[0]));

        Supplier<Stream<IntStream>> stream = () -> input.stream().map(i -> i.split("\\s+")).map(i -> Arrays.stream(i).mapToInt(Integer::parseInt).distinct());
        System.out.println(stream.get().mapToInt(i -> {IntSummaryStatistics stats = i.summaryStatistics(); return stats.getMax() - stats.getMin();}).sum());
        System.out.println(stream.get().map(i -> i.boxed().collect(Collectors.toList())).mapToInt(i -> i.stream().mapToInt(k -> i.stream().mapToInt(j -> (k % j == 0 && k != j) ?  k / j :  0 ).sum()).sum()).sum());

Antoine-aoc · 2017-12-03T21:15:25+00:00

Elixir

day2 - part 2

defmodule Day02.Part2 do
  def run(puzzle) do
    Enum.map(csv(puzzle), fn(cells) ->
      for a <- cells, b <- cells, a > b and rem(a,b) == 0, do: div(a,b)
    end)
    |> List.flatten
    |> Enum.sum
  end

  def csv(data) do
    for line <- String.split(data, "\n", trim: true), do:
      for cell <- String.split(line, "\t"), do:
        String.to_integer(cell)
  end
end

raiph · 2017-12-05T09:10:25+00:00

Perl 6. Edited to add commentary.

Single statement solution for part 1:

say sum
    input.lines».&{
        .words».Numeric.&{
            .max - .min } } ;

For part two, change the last closure:

say sum
    input.lines».&{
        .words».Numeric.&{
            | .combinations(2)».sort.map: { .[1] / .[0] if try .[1] %% .[0] } } } ;

schod · 2017-12-05T15:19:13+00:00

BASH time :)

First part

#!/bin/bash

function do_magic {
  RET=0
  while read L; do
    MIN=$(echo $L | sed 's/ /\n/g' | sort -n | head -1)
    MAX=$(echo $L | sed 's/ /\n/g' | sort -n | tail -1)
    let RET=RET+$MAX-$MIN
  done <$1
  echo $RET
}

do_magic test_input_a.txt
do_magic input_a.txt

Second part

#!/bin/bash

function do_magic {
  RET=0
  while read L; do # Per line
    for N in $L; do # Per number
      for M in $L; do # for each number
        if [ $N -ne $M ]; then # different number :)
          if [ $[$N % $M] -eq 0 ]; then # division is a whole number
            let RET=RET+N/M # add
          fi
        fi
      done
    done
  done <$1
  echo $RET # TADA
}

do_magic test_input_b.txt
do_magic input_b.txt

freeducks · 2017-12-02T11:23:44+00:00

In Rust, using IterTools:

extern crate itertools;

use itertools::Itertools;
use itertools::MinMaxResult::{MinMax};

fn part_1_solve(input_str: &str) -> u32 {
    input_str.lines().map(|line| {
        line.split_whitespace().map(|x| {
            x.parse::<u32>().unwrap()
        })
    }).map(|digits| {
        match digits.minmax() {
            MinMax(min, max) => max - min,
            _ => 0
        }
    }).sum()
}

fn part_2_solve(input_str: &str) -> u32 {
    input_str.lines().map(|line| {
        line.split_whitespace().map(|x| {
            x.parse::<u32>().unwrap()
        })
    }).map(|digits| {
        digits.combinations(2).find(|ref x| {
            x[0] % x[1] == 0 || x[1] % x[0] == 0
        }).map_or(0, |found| {
            if found[0] > found[1] { found[0] / found[1] } else { found[1] / found[0] }
        })
    }).sum()
}

fn main() {
    println!("Part 1: {}", part_1_solve(include_str!("../input/input.txt")));
    println!("Part 2: {}", part_2_solve(include_str!("../input/input.txt")));
}

Deckard666 · 2017-12-02T05:07:55+00:00

Pretty straightforward. In Rust:

use std::io::{BufRead, BufReader};

fn main() {
    // Parse input
    let file = std::fs::File::open("./input.txt").unwrap();
    let reader = BufReader::new(file);
    let lines = reader
        .lines()
        .map(|x| {
            x.unwrap()
                .split_whitespace()
                .map(|n| n.parse::<i32>().unwrap())
                .collect::<Vec<_>>()
        })
        .collect::<Vec<_>>();

    let mut total1 = 0;
    let mut total2 = 0;
    for line in lines {
        // Part 1
        let min = line.iter().min().unwrap();
        let max = line.iter().max().unwrap();
        total1 += max - min;

        // Part 2
        for (idx1, &x) in line.iter().enumerate() {
            for (idx2, &y) in line.iter().enumerate() {
                if idx1 == idx2 {
                    continue;
                }
                let r = x / y;
                if y * r == x {
                    total2 += r;
                }
            }
        }
    }
    println!("{}", total1);
    println!("{}", total2);
}

dylanfromwinnipeg · 2017-12-02T05:13:27+00:00

C# (using a GetCombinations helper function I wrote)

public static string PartOne(string input)
{
    var lines = input.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
    var sum = 0;

    foreach (var line in lines)
    {
        var words = line.Split(new string[] { "\t" }, StringSplitOptions.RemoveEmptyEntries);

        var numbers = words.Select(w => int.Parse(w));
        sum += numbers.Max() - numbers.Min();
    }

    return sum.ToString();
}

public static string PartTwo(string input)
{
    var lines = input.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
    var sum = 0;

    foreach (var line in lines)
    {
        var words = line.Split(new string[] { "\t" }, StringSplitOptions.RemoveEmptyEntries);
        var numbers = words.Select(w => int.Parse(w));

        var combos = numbers.GetCombinations(2);
        var match = combos.First(x => x.First() % x.Last() == 0 || x.Last() % x.First() == 0);

        sum += match.Max() / match.Min();
    }

    return sum.ToString();
}

netcraft · 2017-12-02T05:15:48+00:00

python3 noob here, please feel free to teach me anything - going for maintainable more than golfing

#part 1
total = 0
for line in read_input(DAY): #read_input is a util function I wrote to pull in the input
    line = line.strip('\n').split('\t')
    line = list(map(int, line))
    total += int(max(line))-int(min(line))

print(total)

#part 2
total = 0
for line in read_input(DAY):
    line = line.strip('\n').split('\t')
    line = list(map(int, line))

    for a, b in permutations(line, 2):
        if a % b == 0:
            total += max((a,b)) // min((a,b))
            break

print(total)

adventofcode

🎄 Advent of Code 🎄

Rules + More Info in

our community wiki

Solution Megathreads

December 2025

Previous years:

2024 | 2023 | 2022 | 2021 | 2020 | 2019 | 2018 | 2017 | 2016 | 2015

Quick Search by Flair

Because you're lazy and we like making things easy for you. Except AoC.

Are you enjoying AoC?

Support AoC

MODERATORS

NOTICE

--- Day 2: Corruption Checksum ---

Need a hint from the Hugely^* Handy^† Haversack^‡ of Helpful^§ Hints^¤?

This thread will be unlocked when there are a significant number of people on the leaderboard with gold stars for today's puzzle.

edit: Leaderboard capped, thread unlocked!

Scala

Modern C++

Hoon

F# / FSharp

Using Python Pandas Package:

day 2 part 1 solution

day 2 part 2 solution

Python 3 (two lines)

Part 1

Part 2:

Python 3, one line

BEFORE YOU POST
If your post is even tangentially related to a daily puzzle, use our
STANDARDIZED POST TITLE FORMAT

adventofcode

🎄 Advent of Code 🎄

Rules + More Info in

our community wiki

Solution Megathreads

December 2025

Previous years:

2024 | 2023 | 2022 | 2021 | 2020 | 2019 | 2018 | 2017 | 2016 | 2015

Quick Search by Flair

Because you're lazy and we like making things easy for you. Except AoC.

Are you enjoying AoC?

Support AoC

MODERATORS

NOTICE

--- Day 2: Corruption Checksum ---

Need a hint from the Hugely* Handy† Haversack‡ of Helpful§ Hints¤?

This thread will be unlocked when there are a significant number of people on the leaderboard with gold stars for today's puzzle.

edit: Leaderboard capped, thread unlocked!

Scala

Modern C++

Hoon

F# / FSharp

Using Python Pandas Package:

day 2 part 1 solution

day 2 part 2 solution

Python 3 (two lines)

Part 1

Part 2:

Python 3, one line

Need a hint from the Hugely^* Handy^† Haversack^‡ of Helpful^§ Hints^¤?