Day 1: Report Repair

function main()

    # Initialize array and read in input
    open("Day1/input.txt") do fp
        nums = map(x -> parse(Int, x), readlines(fp))
    end

    # Using sets, calculate remainders from 2020 and then intersect to find numbers in both
    nums = Set(nums)
    remainders = Set(2020 .- nums)
    targets_1 = intersect(nums, remainders)
    
    # Calculate and display what we need
    result_1 = prod(targets_1)
    println("Part 1 result is ", result_1)

    # Use implicit expansion to subtract the numbers
    second_remainders = Set(collect(remainders) .- collect(nums)')
    targets_2 = intersect(nums, second_remainders)

    # Calculate and display what we need
    result_2 = prod(targets_2)
    println("Part 2 result is ", result_2)
end

main()

use std::io;
use std::process;
use std::env;

fn recursive_sum(remaining_entries: &[i32], considered: &mut Vec<i32>, target_num_terms: i32, target_sum: i32) {
    if considered.len() as i32 == target_num_terms - 1 {
        for x in remaining_entries {
            if considered.iter().sum::<i32>() + x == target_sum {
                let product: i32 = considered.iter().product::<i32>() * x;
                println!("{}", product);
                process::exit(0);
            }
        }
    } else {
        for x in 0..remaining_entries.len() {
            considered.push(remaining_entries[x]);
            recursive_sum(&remaining_entries[x+1..], considered, target_num_terms, target_sum);
            considered.pop();
        }
    }
}

fn main() -> io::Result<()> {
    let args: Vec<String> = env::args().collect();

    let target_num_terms: i32 = args[1].parse().unwrap();
    let target_sum: i32 = args[2].parse().unwrap();

    let mut entries = Vec::new();
    let mut buffer = String::new();
    let mut considered = Vec::new();

    let stdin = io::stdin();

    while let Ok(_) = stdin.read_line(&mut buffer) {
        let new = buffer.trim().parse::<i32>().unwrap();
        buffer.clear();

        entries.push(new);

        if entries.len() >= target_num_terms as usize {
            recursive_sum(&entries, &mut considered, target_num_terms, target_sum);
	    considered.clear();
        }
    }

    Ok(())
}

#!/usr/bin/python3

with open("expensereport","r") as file:
    lines = file.readlines()


for i in lines:
    for j in lines:
        if int(i) + int(j) == 2020:
            print(int(i) * int(j))

#!/usr/bin/python3
with open("expensereport","r") as file:
    lines = file.readlines()
    lines = [int(line.replace("\n","")) for line in lines]



# part 1
for i in lines:
    if 2020 - i in lines:
        print(i * (2020 - i))

# part 2
for i in lines:
    for j in lines:
        if 2020 - i - j in lines:
            print(i * j * (2020 - i - j))

const fs = require('fs');
const readline = require('readline');

let numArr = [];

async function openFileForReading(file) {
	const fileStream = fs.createReadStream(file);

	const rl = readline.createInterface({
		input: fileStream,
		crlfDelay: Infinity
	});

	for await (const line of rl) {
		try {
			numArr.push(parseInt(line));
		} catch(e) {
			console.error(e);
		}
	}
}

(async function mainExecution() {
	await openFileForReading('input.txt');
	//test: 1667
	// find the entries that sum to 2020
	for (const num1 of numArr) {
		const num2 = 2020 - num1;
		if (numArr.includes(num2)) {
			console.log("Answer found! " + num1 + " * " + num2 + " = " + (num1 * num2));
			break;
		}
	}
})();

const fs = require('fs');
const readline = require('readline');

let numArr = [];

async function openFileForReading(file) {
	const fileStream = fs.createReadStream(file);

	const rl = readline.createInterface({
		input: fileStream,
		crlfDelay: Infinity
	});

	for await (const line of rl) {
		try {
			numArr.push(parseInt(line));
		} catch(e) {
			console.error(e);
		}
	}
}

(async function mainExecution() {
	await openFileForReading('input.txt');
	// find the entries that sum to 2020
	for (const num1 of numArr) {
		for (const num2 of numArr) {
			const num3 = 2020 - num1 - num2;
			if (num3 <= 0) continue;
			if (numArr.includes(num3)) {
				console.log("Answer found! " + num1 + " * " + num2 + " * " + num3 + " = " + (num1 * num2 * num3));
				return;
			}
		}
	}
})();

(define (get-lines parse-line)
  (with-input-from-file "input"
    (lambda ()
      (let loop ((line (read-line))
                 (lines '()))
        (if (eof-object? line)
            (reverse lines)
            (loop (read-line)
                  (cons (parse-line line) lines)))))))

(define lines (get-lines string->number))

(define (2sum target numbers)
  (let ((passed (make-weak-eq-hash-table)))
    (let loop ((numbers numbers))
      (if (null? numbers) #f
          (let* ((x (car numbers))
                 (complement (- target x)))
            (if (and (>= complement 0)
                     (hash-table/get passed complement #f))
                (* x complement)
                (begin
                  (hash-table/put! passed x #t)
                  (loop (cdr numbers)))))))))

(define (3sum target numbers)
  (if (null? numbers) #f
      (let* ((x (car numbers))
             (complement (- target x))
             (remaining (cdr numbers)))
        (if (>= complement 0)
            (let ((complement-product (2sum complement remaining)))
              (if complement-product
                  (* x complement-product)
                  (3sum target remaining)))
            (3sum target remaining)))))

(define (one numbers) (2sum 2020 numbers))
(define (two numbers) (3sum 2020 numbers))
(one lines)
(two lines)

#!/usr/bin/awk -f
{ arr[i++] = $0 }

END {
        for (j = 0; j < i; ++j)
                for (k = j; k < i; ++k)
                        if (arr[j] + arr[k] == 2020)
                                print arr[j] * arr[k]
}

#!/usr/bin/awk -f
{ arr[i++] = $0 }

END {
        for (j = 0; j < i; ++j)
                for (k = j; k < i; ++k)
                        for (l = k; l < i; ++l)
                                if (arr[j] + arr[k] + arr[l] == 2020)
                                        print arr[j] * arr[k] * arr[l]
}

test_data = '''1721
979
366
299
675
1456'''

numbers = test_data.split('\n')

for i in range(0, len(numbers)): 
    numbers[i] = int(numbers[i]) 
    
    
for num1 in numbers:
    for num2 in numbers:
         if num1 != num2 and num1 + num2 == 2020:
                print(f"Match Found: {num1} + {num2} = 2020")
                print(f"{num1} * {num2} = {num1 * num2}")

test_data = '''1721
979
366
299
675
1456'''

numbers = test_data.split('\n')

for i in range(0, len(numbers)): 
    numbers[i] = int(numbers[i]) 
    
    
for num1 in numbers:
    for num2 in numbers:
        for num3 in numbers:
            if num1 != num2 and num1 != num3 and num2 != num3 and num1 + num2 + num3 == 2020:
                print(f"Match Found: {num1} + {num2} + {num3} = 2020")
                print(f"{num1} * {num2} * {num3} = {num1 * num2 * num3}")

import time
start = time.perf_counter_ns()


f = open("input.txt", "r")
input = f.readlines()
input_arr = [int(i) for i in input]
input_arr.sort()
i = 0
j = len(input_arr)-1
while i<j:
    left_number = input_arr[i]
    right_number = input_arr[j]
    result = left_number+right_number
    if result == 2020:
        # result
        print(left_number*right_number)
        break
    elif result < 2020:
        i+=1
    elif result > 2020:
        j-=1

end = time.perf_counter_ns()
duration = (end - start) / 1_000_000
print(f' {duration:.06f} milliseconds')

=ARRAYFORMULA(
  TRANSPOSE(
   QUERY(
    SPLIT(
     FLATTEN(
      IF(ISBLANK(A2:A),,
       (A2:A+TRANSPOSE(FILTER(A2:A,A2:A<>""))&"|"&
       A2:A&"|"&TRANSPOSE(FILTER(A2:A,A2:A<>""))))),
     "|"),
    "select Col2, Col3 
     where Col1 = 2020 
     limit 1")))

=ARRAYFORMULA(
  UNIQUE(
   QUERY(
    FLATTEN(
     IF(ISBLANK(A2:A),,
      IFERROR(
       VLOOKUP(
        2020-
         (A2:A+TRANSPOSE(FILTER(A2:A,A2:A<>""))),
        A2:A,1,FALSE)))),
    "select Col1 
     where Col1 is not null")))

expensereport = open("day1input", 'r')
entries = []

for line in expensereport:
    entries.append(int(line))

def findtriumvirs(entries, value1):
    for entry in entries:
        value2 = findpair(entries, (entry + value1))
        if value2 == (2020 - (entry + value1)):
            values = [value1, value2, entry]
            return values

def findpair(entries, value1):
    value2 = 2020 - value1
    for entry in entries:
        if entry == value2:
            return entry
    #this saves some time on part 1
    #entries.remove(entry)
    return None

for entry in entries:
    values = findtriumvirs(entries, entry)
    if values:
        break

product = values[0] * values[1] * values[2]

print("values are " + str(values) + " and product is " + str(product))

#!/usr/bin/env python
# Create empty list and import data into it as integers
expenses = []
with open("day_01_input.csv", "r") as input:
    for line in input.readlines():
        expenses.append(int(line))
        
# Set target number, length of input list, and starting index i
target = 2020
length = len(expenses)

# Two numbers summing to target
i = 0 
while i < length:
    for n in range(i+1, length):
        if expenses[i] + expenses[n] == target:
            print(expenses[i] * expenses[n])
    i+=1

#!/usr/bin/env python
# Create empty list and import data into it as integers
expenses = []
with open("day_01_input.csv", "r") as input:
    for line in input.readlines():
        expenses.append(int(line))
        
# Set target number, length of input list, and starting index i
target = 2020
length = len(expenses)

# Three numbers summing to target
i = 0
while i < length:
    for n in range(i+1, length):
        for m in range(n+1,length):
            if expenses[i] + expenses[n] + expenses[m] == target:
                print(expenses[i] * expenses[n] * expenses[m])
    i+=1

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;

public class ReportRepair {
  public static void main (String[] args) {
    long startTime = System.nanoTime();
    ArrayList<Integer> input = new ArrayList<>();

    // get input
    BufferedReader reader;
    try {
      String filePath = new File("").getAbsolutePath();
      filePath = filePath.concat("/input.txt");
      reader = new BufferedReader(new FileReader(filePath));
      String line = reader.readLine();
      while (line != null) {
        input.add(Integer.parseInt(line));
        line = reader.readLine();
      }
      reader.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
    // end get input

    // Create a hashmap of the complement, then we can look for the complement afterwards
    HashMap<Integer, Boolean> complements = new HashMap<>();
    int answer = 0;
    for(int i : input) {
      if (complements.containsKey(i)) {
        answer = i * (2020 - i);
        break;
      }
      int complement = 2020 - i;
      complements.put(complement, true);
    }
    if (answer != 0) {
      System.out.println( answer );
    } else {
      System.out.println( "No answer found" );
    }
    long endTime   = System.nanoTime();
    long totalTime = endTime - startTime;
    System.out.println("Time completed: " + totalTime + " nanoseconds");
  }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;

public class ReportRepairPt2 {
  public static void main (String[] args) {
    long startTime = System.nanoTime();
    ArrayList<Integer> input = new ArrayList<>();

    // get input
    BufferedReader reader;
    try {
      String filePath = new File("").getAbsolutePath();
      filePath = filePath.concat("/input.txt");
      reader = new BufferedReader(new FileReader(filePath));
      String line = reader.readLine();
      while (line != null) {
        input.add(Integer.parseInt(line));
        line = reader.readLine();
      }
      reader.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
    // end get input

    // Create a hashmap of the complement, then we can look for the complement afterwards
    HashMap<Integer, Integer> complements = new HashMap<>();
    for(int i : input) {
      int partialSum = 2020 - i;
      complements.put(partialSum, i);
    }

    int answer = 0;

    for(int i : input) {
      for(int j : input) {
        int comboSum = i + j;
        if (complements.containsKey( comboSum )) {
          int thirdValue = complements.get( comboSum );
          answer = thirdValue * i * j;
          break;
        }
      }
    }

    if (answer != 0) {
      System.out.println( answer );
    } else {
      System.out.println( "No answer found" );
    }
    long endTime   = System.nanoTime();
    long totalTime = endTime - startTime;
    System.out.println("Time completed: " + totalTime + " nanoseconds");
  }
}

using System;
using static System.Console;
using System.IO;
//It's all in one block because I'm basically adding them all in line.  200^3 is a *lot* of numbers, though.
class Advent1 {
    
    static void Main() {
        string[] lines = System.IO.File.ReadAllLines(Path.Combine(Directory.GetCurrentDirectory(), "input"));
        string doublemult = "";
        string tripmult = "";
        foreach (string line in lines)
        {
            int int1 = Convert.ToInt32(line);
            foreach (string line2 in lines)
            {
                int int2 = Convert.ToInt32(line2);
                if (int1 + int2 == 2020)
                {
                    doublemult = (int1 * int2).ToString();
                }
                foreach (string line3 in lines)
                    {
                        int int3 = Convert.ToInt32(line3);
                        if (int1 + int2 + int3 == 2020)
                        {

                            tripmult = (int1 * int2 * int3).ToString();
                        }
                    }
            }
        }
        WriteLine("The multiple of two numbers that add up to 2020 is: {0}", doublemult);
        WriteLine("The multiple of three numberst that add up to 2020 is: {0}", tripmult);
        ReadKey();

    }
}