import java.nio.file.Files
import java.nio.file.Paths
import kotlin.math.max

private const val FILENAME = "src/main/resources/day01.txt"

fun fuelNeeded(mass: Int) = max((mass / 3) - 2, 0)


fun totalFuelNeeded(mass: Int): Int {
    var fuel = fuelNeeded(mass)
    var totalFuel = fuel
    while (fuel != 0) {
        fuel = fuelNeeded(fuel)
        totalFuel += fuel
    }
    return totalFuel
}

fun part1() = Files.readAllLines(Paths.get(FILENAME))
    .sumBy { fuelNeeded(it.toInt()) }
    .toString()

fun part2() = Files.readAllLines(Paths.get(FILENAME))
    .sumBy { totalFuelNeeded(it.toInt()) }
    .toString()

fun main() {
    println("Part 1: ${part1()}")
    println("Part 2: ${part2()}")
}

(ns ballpointcarrot.aoc
  (:require [clojure.string :as st]))


(defn fuel-cost
  [value]
  (- (Math/floor (/ value 3)) 2))

(defn adj-fuel-cost
  [value]
  (let [fuel (fuel-cost value)]
    (if (pos? fuel)
      fuel
      0)))

(defn p2019-01
  "Calculate Fuel requirements"
  [input]
  (apply +
         (map #(fuel-cost (Integer/parseInt %)) (st/split-lines input))))

(defn recursive-fuel-cost
  [value]
  (loop [remains value
         total 0]
    (if (= remains 0)
      total
      (let [fuel (adj-fuel-cost remains)]
        (recur fuel (+ total fuel))))))

(defn p2019-01-part2
  "Calculate fuel requirements, including weight of fuel"
  [input]
  (apply +
         (map #(recursive-fuel-cost (Integer/parseInt %)) (st/split-lines input))))

const fs = require('fs');
const data = fs.readFileSync('../2019 Solutions/inputs/day01input.txt').toString();
const input = data.split('\r\n').map(Number);
const testInput = [
  14,
  1969,
  100756
];

// mass / 3, round down, -2
function formula(mass) {
  return Math.floor(mass / 3) - 2;
}

// Part 1
const fuelOfMass = input.map((curr) => {
  return formula(curr);
});

const totalFuel = fuelOfMass.reduce((acc, curr) => {
  return acc + curr;
}, 0);

console.log(`Part 1: ${totalFuel}`);

// Part 2

const totalFuelOfMass = input.map((curr) => {
  let value = curr;
  let accumulator = [];

  do {
    value = formula(value);
    if (value > 0) {
      accumulator.push(value);
    }
  } while (value > 0);

  return accumulator.reduce((acc, curr) => {
    return acc + curr;
  }, 0);
});

const newTotalFuel = totalFuelOfMass.reduce((acc, curr) => {
  return acc + curr;
}, 0);

console.log(`Part 2: ${newTotalFuel}`);

fn part_a(input: Vec<u32>) {
    let output: u32 = input.iter().map(|val| (val - (val % 3)) / 3 - 2).sum();
    println!("{:?}", output);
}

fn part_b(input: Vec<u32>) {
    let output: u32 = input.iter().map(|val| rec_fuel_calc(*val)).sum();
    println!("{:?}", output);
}

fn rec_fuel_calc(mass: u32) -> u32 {
    let answer = ((mass - (mass % 3)) / 3) - 2;
    if answer < 9 {
        return answer;
    } else {
        return answer + rec_fuel_calc(answer);
    }
}

/// Day 1: The Tyranny of the Rocket Equation
/// 
/// Calculate the amount of fuel required to launch your spaceship!

use std::fs::File;
use std::io::prelude::*;
use std::io::BufReader;

/// Calculate the fuel required to lift one module, based on its mass
fn fuel_required(mass: &usize) -> usize {
    (mass / 3) - 2
}

/// Calculates the fuel required to lift one module, but factors in the
/// weight of the fuel as well
fn recursive_fuel_required(mass: &usize) -> usize {
    if *mass <= 6 {
        0
    } else {
        let next_mass = (mass / 3) - 2;
        next_mass + recursive_fuel_required(&next_mass)
    }
}

/// Calculate the total fuel requirements for the launch
fn fuel_requirements(module_masses: Vec<usize>) -> usize {
    module_masses.iter().map(recursive_fuel_required).sum()
}


/// Parses the input file, which is a bunch of numbers, one per line
fn parse_input() -> Vec<usize> {
    let buf = BufReader::new(File::open("data/day1.txt").unwrap());
    buf.lines()
        .map(|result| result.unwrap())
        .map(|line| line.parse::<usize>().unwrap())
        .collect()
}

/// Main day 1 code
pub fn run() {
    let data = parse_input();
    let total_requirements = fuel_requirements(data);
    println!("Total fuel required: {}", total_requirements);
}

import Test.Hspec

load :: String -> [Int]
load = map read . lines

moduleFuel :: Int -> Int
moduleFuel mass = (mass `div` 3) - 2

fuelFuel :: Int -> Int
fuelFuel fuel = fuel + fuel' (moduleFuel fuel)
  where
    fuel' f = if f <= 0 then 0 else fuelFuel f 

part1 :: [Int] -> Int
part1 = sum . map moduleFuel

part2 :: [Int] -> Int
part2 = sum . map (fuelFuel . moduleFuel)

testModuleFuel = do
  moduleFuel 12 `shouldBe` 2
  moduleFuel 14 `shouldBe` 2
  moduleFuel 1969 `shouldBe` 654
  moduleFuel 100756 `shouldBe` 33583

testFuelFuel = do
  fuelFuel 2 `shouldBe` 2
  fuelFuel 654 `shouldBe` 966
  fuelFuel 33583 `shouldBe` 50346

test = do
  testModuleFuel
  testFuelFuel

main = do
  test
  input <- fmap load $ readFile "input.txt"
  putStrLn $ "Part 1 : " ++ (show $ part1 input)
  putStrLn $ "Part 2 : " ++ (show $ part2 input)

from typing import Sequence

def load(file):
    with open(file, "rt") as f:
        return list(int(line) for line in f.readlines())

def moduleFuel(mass: int) -> int:
    return (mass // 3) - 2

def fuelFuel(mass: int) -> int:
    f = moduleFuel(mass)
    return mass + (0 if f <= 0 else fuelFuel(f))

def testModuleFuel():
    assert(moduleFuel(12) == 2)
    assert(moduleFuel(14) == 2)
    assert(moduleFuel(1969) == 654)
    assert(moduleFuel(100756) == 33583)

def testFuelFuel():
    assert(fuelFuel(2) == 2)
    assert(fuelFuel(654) == 966)
    assert(fuelFuel(33583) == 50346)


def part1(modules: Sequence[int]) -> int:
    return sum(moduleFuel(f) for f in modules)

def part2(modules: Sequence[int]) -> int:
    return sum(fuelFuel(moduleFuel(f)) for f in modules)

if __name__ == "__main__":
    testModuleFuel()
    testFuelFuel()
    input = load("input.txt")
    print(f"Part 1 : {part1(input)}")
    print(f"Part 2 : {part2(input)}")

using Test

load(file::AbstractString) = [parse(Int, line) for line in readlines(file)]

moduleFuel(mass::Int) = div(mass, 3) - 2

function fuelFuel(mass::Int)
  f = moduleFuel(mass)
  mass + if f <= 0 0 else fuelFuel(f) end
end

@testset "ModuleFuel" begin
  @test moduleFuel(12) == 2
  @test moduleFuel(14) == 2
  @test moduleFuel(1969) == 654
  @test moduleFuel(100756) == 33583
end

@testset "FuelFuel" begin
  @test fuelFuel(2) == 2
  @test fuelFuel(654) == 966
  @test fuelFuel(33583) == 50346
end

part1(modules) = sum(moduleFuel(m) for m in modules)

part2(modules) = sum(fuelFuel(moduleFuel(m)) for m in modules)

input = load("input.txt")
println("Part 1 : $(part1(input))")
println("Part 2 : $(part2(input))")

input = np.array([input])
output = np.sum(np.floor(input / 3) - 2)

for module in input_array:
    new_fuel = mod
    while True:
        new_fuel = np.floor(new_fuel / 3) - 2
        if new_fuel > 0:
            total_fuel += new_fuel
        else:
            break

var fs = require("fs");
var text = fs.readFileSync("./data.txt").toString('utf-8');
var textByLine = text.split("\n");

var sum = 0;

for(i=0; i < textByLine.length; i++){
    textByLine[i] = parseInt(textByLine[i]);
    textByLine[i] = Math.floor(textByLine[i]/3)-2;
    sum += textByLine[i];
}
console.log(sum);

var fs = require("fs");
var text = fs.readFileSync("./data.txt").toString('utf-8');
var textByLine = text.split("\n");

var sum = 0;
var fuels = [];

function calculateFuel(module){
    if(module > 0) {
        module = Math.floor(module/3)-2;
        if (module > 0) {
            fuels.push(module)
        } else {
            return null;
        }
        calculateFuel(module);
    } else {
        return null;
    }
}

for(i=0; i < textByLine.length; i++){
    textByLine[i] = parseInt(textByLine[i]);
    textByLine[i] = calculateFuel(textByLine[i]);
}

for(j=0; j < fuels.length; j++){
    sum += fuels[j];
}

console.log(sum);

func fuel(forMass mass: Int) -> Int {
    return Int((Double(mass) / 3).rounded(.down) - 2)
}

func partOne() {
    var total = 0
    input.components(separatedBy: .newlines).map{ input in
        total = total + fuel(forMass: Int(input) ?? 0)
    }
    print(total)
}

func fuel(forMass mass: Int, includesFuelMass: Bool) -> Int {
    if !includesFuelMass {
        return fuel(forMass: mass)
    }

    var currentFuel = mass
    var total = 0
    while true {
        let fuels = fuel(forMass: currentFuel)
        if fuels < 0 {
            break
        }
        currentFuel = fuels
        total = total + currentFuel
    }
    return total
}

func partTwo() {
    var total = 0
    input.components(separatedBy: .newlines).map{ input in
        total = total + fuel(forMass: Int(input) ?? 0, includesFuelMass: true)
    }
    print(total)
}

partOne()
partTwo()

#advent of code day 1
#lets open the input file
target = File.open("input.txt")
#part 1
def calculation (file)
    total = 0
    file.each{|number|
    number = number.to_i / 3 - 2
    total += number 
    }
    puts "Our total is - #{total}"
end

calculation(target)
target.close

defmodule Day01 do
  def mass_calc([]), do: 0
  def mass_calc([ head | tail]), do: fuel(head) + mass_calc(tail)
  def fuel(mass), do: floor(mass / 3) - 2
end

Day01.mass_calc([146561, 98430, 131957, 81605, 70644, 55060, 93217, 107158, 110769, 94650, 141070, 72381, 100736, 105705, 99003, 94057, 110662, 74429, 55509, 63492, 102007, 72627, 95183, 112072, 122313, 116884, 125451, 106093, 140678, 121751, 149018, 58459, 138306, 149688, 82927, 72676, 95010, 88439, 51807, 103175, 107633, 126439, 128879, 112054, 52873, 114493, 77365, 76768, 60838, 89692, 66217, 96060, 100338, 139063, 126869, 106490, 128967, 116312, 56822, 52422, 124579, 117120, 106245, 105255, 66975, 115340, 145764, 
149427, 64228, 64237, 67887, 103345, 134901, 50226, 126991, 122314, 140818, 129687, 149792, 101148, 73411, 87078, 121272, 108804, 96063, 81155, 62058, 112684, 134263, 128454, 99455, 91689, 141448, 143892, 103257, 64352, 90769, 78307, 111855, 130153])

defmodule Aoc19.Day1b do
  @moduledoc false

  alias Aoc19.Utils.Common
  alias Aoc19.Utils.Day1, as: Day1Utils

  def start(input_location) do
    input_location
    |> Common.read_numbers()
    |> Enum.reduce(0, &fuel/2)
    |> trunc()
  end

  def fuel(0, total), do: total

  def fuel(mass, total) do
    fuel =
      mass
      |> Day1Utils.fuel()
      |> Kernel.max(0)

    fuel(fuel, total + fuel)
  end
end