AoC Day 1: Chronal Calibration

const fs = require('fs');

const datas = fs.readFileSync('input.txt', 'utf-8');
let currFrequency = new Set();

const changes = datas.split(/\n|\r/m)
    .map(Number);

let frequency = 0;
let i = 0;

while (true) {
    frequency += changes[i];
    if (currFrequency.has(frequency)) {
        console.log(frequency);
        break;
    }
    currFrequency.add(frequency);
    i = i === changes.length - 1 ? 0 : i + 1;
}

var fs = require('fs');

fs.readFile('./numbers.txt', 'utf8', function(err, contents) {
  console.log(eval(contents));
});

var fs = require('fs');

const hash = {};

fs.readFile('./numbers.txt', 'utf8', function(err, contents) {
  const lines = contents.split('\n');
  let current = 0;
  let i = 0;
  while(true) {
    if(i === lines.length-1) {
      i = 0;
    }
    const line = lines[i];
    const old = current;
    const num = Number(line)
    current += num;
    if(hash[current]) {
      console.log(current);
      break;
    }
    hash[current] = true;
    console.log(old, '+', num, '->', current);
    i++;
  }
});

BEGIN {
    f = 0
}

{
    f += $1
}

END {
    print f
}

awk -f 1.1.awk 1.1.input

BEGIN {
    f = 0
    a[0] = 1
}

{
    f += $1
    if (f in a) {
        a[f] += 1
    } else {
        a[f] = 1
    }
    if (a[f] == 2) {
        print(f)
        exit 0
    }
    # Resets what file is the next to process
    ARGIND=0
}

awk -f 1.2.awk 1.2.input

Console.WriteLine(File.ReadAllLines(@".\day1_input.txt").Sum(s => int.Parse(s)));

int[] input = File.ReadAllLines(@".\day1_input.txt").Select(s => int.Parse(s)).ToArray();
HashSet<int> set = new HashSet<int>();
int freq = 0;
for (int i = 0; set.Add(freq = freq + input[i % input.Length]); i++) ;
Console.WriteLine(freq);

print("The final calculated frequency is: \(frequencyInput.reduce(0,+))")

let frequency = frequencyInput.reduce(0, { x, y in
    x + y
})

/// A closure that takes an `Array` of `Int` values and adds them together in a loop. Upon finding the first repeated
/// value it breaks and returns.
let findRepeatedFrequency = {(_ inputArray: [Int]) -> Int in
    var accumilated = 0
    var frequencies = Set<Int>()
    while true {
        for skew in inputArray {
            accumilated += skew
            if frequencies.contains(accumilated) {
                return accumilated
            }
            frequencies.insert(accumilated)
        }
    }
}

print("The first repeated frequency is: \(findRepeatedFrequency(frequencyInput))")

(->>
  (utils/read-file (str utils/resources-path "day1.txt"))
  (map #(Integer. ^String %))
  (apply +))

(->>
   (utils/read-file (str utils/resources-path "day1.txt"))
   (map #(Integer. ^String %))
   (cycle)
   (reduce
     (fn [{:keys [freq seen]} freq-change]
       (if (seen freq)
         (reduced freq)
         {:freq (+ freq freq-change) :seen (conj seen freq)}))
     {:freq 0 :seen #{}}))

<?=array_sum(file('input'));

package adventofcode2018.day1

import java.io.File

/** Infinitely repeat a sequence */
fun <T> Sequence<T>.repeat() = generateSequence { asIterable() }.flatten()

/** Like fold() but returns a sequence of all the accumulator values,
 *  not just the last one. `seq.scanl(i, f).last() == seq.fold(i, f)` */
fun <T, U> Sequence<T>.scanl(initial: U, f: (U, T) -> U): Sequence<U> {
    var acc: U = initial
    return map { x -> acc = f(acc, x); acc }
}

fun main(args: Array<String>) {
    val input: List<Int> = File("input.txt").readLines().map(String::toInt)

    // part 1
    val result = input.sum()
    println("Part 1 result: ${result}")

    // part 2
    val repeatedInput = input.asSequence().repeat()
    val accumulatedInput = repeatedInput.scanl(0, Int::plus)
    val unconsumed = accumulatedInput.dropWhile(mutableSetOf<Int>()::add)
    println("Part 2 result: ${unconsumed.first()}")
}

const fs = require('fs');

// Read the input
let contents = fs.readFileSync('frequenciesDiff.txt','utf8');

// Parse to a int array
let diffs = contents.split("\n").map(item => parseInt(item));

// Reduce
let result = diffs.reduce((a,b) => a+b);


// Profit!
console.log(result);

const fs = require('fs');

function duplicateFinder(diffs) {
    // Init an empty memo. We'll store here frequency values for easy retrieval
    let memo = {};

    let currentFrequency = 0;
    let i = 0;

    // Loop until currentFrequency is already in the memo.
    // When the loop breaks, it will be because currentFrequency got a value that had before. 
    // This means it's the second time it appears
    while (!(currentFrequency in memo)) {
        memo[currentFrequency] = currentFrequency.toString();

        currentFrequency += diffs[i];
        i = ++i % diffs.length
    }
    return currentFrequency;
}

// Read the input
let contents = fs.readFileSync('frequenciesDiff.txt', 'utf8');

// Parse to a int array
let diffs = contents.split("\n").map(item => parseInt(item));

// Do the work
let result = duplicateFinder(diffs);

// Profit!
console.log(result);

let rec f freq ic =
  try f (freq + int_of_string (input_line ic)) ic
  with End_of_file -> freq

let () = Printf.printf "%d\n" (f 0 stdin)

let rec read_changes changes ic =
  let next_line = try Some (input_line ic) with End_of_file -> None in
  match next_line with
  | None -> List.rev changes
  | Some c -> read_changes (int_of_string c :: changes) ic

let rec f freq freqs changes_done = function
  | [] -> f freq freqs [] (List.rev changes_done)
  | c :: r ->
    let freq' = freq + c in
    if List.mem freq' freqs then freq'
    else f freq' (freq' :: freqs) (c :: changes_done) r

let () = Printf.printf "%d\n" (f 0 [0] [] (read_changes [] stdin))

const data = document.querySelector('pre').innerText

const frequencies = data.split('\n')

function getFrequency (freqs) {
  return freqs.reduce((acc, val) => {
    const sign = val[0] === '+' ? 1 : -1
    const number = val.substring(1)

    return acc + sign * number
  }, 0)
}

const result = getFrequency(frequencies)
console.log(result)

const data = document.querySelector('pre').innerText

const frequencies = data.split('\n')
let sums = []

function getFrequency (freqs, acc=0, callback) {
  return freqs.reduce((acc, val) => {
    const sign = val[0] === '+' ? 1 : -1
    const number = val.substring(1)
    const current = acc + sign * number
    callback(current)
    return current
  }, acc)
}

let startFreq = getFrequency(frequencies, 0, current => sums.push(current))

function isMatch (arr, el) {
  return arr.find(element => element === el)
}

function findMatch () {
    let matchFound = false

    while(!matchFound) {
    startFreq = getFrequency(frequencies, startFreq, current => {
      if (isMatch(sums, current)) {
        matchFound = true
        console.log('The match is', current)
      }
    })
    }
}

findMatch()

class Device
  getter frequency : Int32
  getter duplicate : Int32 | Nil

  def initialize
    @frequency = 0
    @duplicate = nil
    @frequencies = Set{@frequency}
  end

  def update(input : Array(String))
    @frequency = input.map { |string| string.to_i }.reduce(@frequency) do |acc, i|
      frequency = acc + i
      @duplicate = frequency if @frequencies.includes?(frequency) && @duplicate.nil?
      @frequencies.add(frequency)
      frequency
    end
  end

  def find_duplicate(input : Array(String))
    while @duplicate.nil?
      update(input)
    end
  end
end


puts "--- Day 1: Chronal Calibration ---"
input = File.read_lines("./01/input.txt")
device = Device.new
device.update(input)
puts "Frequency result: #{device.frequency}"
device.find_duplicate(input)
puts "Frequency first duplicates at: #{device.duplicate}"