ToCode

export default function Main() {
  return (
    <>
      <style>
        {\
          h1 { color: red }
          body { background: yellow; }
          a { color: blue }
          \}
      </style>
      <h1>Hello World</h1>
    </>
  )
}

export default function Main() {
  return (
    <>
      <style href="main" precedence="medium">
        {\
          h1 { color: red }
          body { background: yellow; }
          a { color: blue }
          \}
      </style>
      <h1>Hello World</h1>
    </>
  )
}

def step
    @guard.step
    if @matrix[@guard.coords] == '#'
      @guard.back
      @guard.turn
    end

    @time_loop = true if @visited.include?([@guard.coords, @guard.heading])
    @visited << [@guard.coords, @guard.heading] if @matrix.key?(@guard.coords)
  end

  def run
    step_count = 0
    turn_count = 0
    while (@matrix.key?(@guard.coords) && !@time_loop) do
      guard_before = @guard.coords
      step
      step_count += 1
      turn_count += 1 if @guard.coords == guard_before
    end
    
    # Return important values - makes testing easier
    [@time_loop, step_count, turn_count]
  end
  
  def reset
    @time_loop = false
    @visited = Set.new
    @guard = Guard.new(Complex(@guard_start[0], @guard_start[1]))
    @visited << [@guard.coords, @guard.heading]
  end
end

def find_time_loops(room)
  start = room.visited.first
  room.run
  
  # Extract the coordinates of visited positions, excluding the start
  visited_positions = (room.visited - Set.new([start])).map(&:first).to_set
  
  # Find positions that cause time loops
  time_loops = visited_positions.select do |coords|
    original_value = room.matrix[coords]
    room.matrix[coords] = '#'
    room.reset
    result = room.run.first  # Check if a time loop occurred
    
    # Restore the original value and reset the room
    room.matrix[coords] = original_value
    room.reset
    
    result
  end
  
  time_loops.length
end

* Main execution *
room = Room.new
puts find_time_loops(room)

visited << [guard.coords, guard.heading]
  end

require 'set'

class Guard
  attr_accessor :position, :heading
  def initialize(position)
    self.heading = -1 + 0i
    self.position = position
  end

  def step
    self.position = position + heading
  end

  def turn
    self.heading = Complex(heading.imag, -heading.real)
  end

  def back
    self.position = position - heading
  end

  def coords
    [position.real, position.imag]
  end
end

class Room
  attr_accessor :matrix, :guard, :visited, :time_loop, :guard_start

  def initialize()
    self.time_loop = false
    self.visited = Set.new
    self.matrix = File.read('input.txt').lines.each_with_index.flat_map do |line, line_index|
      line.chomp.split('').each_with_index.map do |char, column_index|
        if char == '^'
          self.guard_start = [line_index, column_index]
          self.guard = Guard.new(Complex(line_index, column_index))
          { [line_index, column_index] => '.' }
        else
          { [line_index, column_index] => char }
        end
      end
    end.reduce({}) {|acc, val| acc.merge(val) }
    visited << [guard.coords, guard.heading]
  end

  def step
    guard.step
    if matrix[guard.coords] == '#'
      guard.back
      guard.turn
    end

    self.time_loop = true if visited.include?([guard.coords, guard.heading])
    visited << [guard.coords, guard.heading] if matrix.key?(guard.coords)
  end

  def run
    step_count = 0
    turn_count = 0
    while (matrix.key?(guard.coords) && !time_loop) do
      guard_before = guard.coords
      step
      step_count += 1
      if guard.coords == guard_before
        turn_count += 1
      end
    end
  end
end

room = Room.new
start = room.visited.first
room.run

time_loops = (room.visited - Set.new([start])).map(&:first).to_set.filter do |coords|
  room.matrix[coords] = '#'
  room.run
  time_loop = room.time_loop

  room.time_loop = false
  room.matrix[coords] = '.'
  room.visited = Set.new
  room.guard = Guard.new(Complex(room.guard_start[0], room.guard_start[1]))

  time_loop
end

pp time_loops.length

require 'set'

class Guard
  attr_accessor :position, :heading
  
  def initialize(position)
    @heading = -1 + 0i  # Using instance variables consistently
    @position = position
  end

  def step
    @position += @heading  # Using += for cleaner code
  end

  def turn
    @heading = Complex(@heading.imag, -@heading.real)
  end

  def back
    @position -= @heading  # Using -= for cleaner code
  end

  def coords
    [@position.real.to_i, @position.imag.to_i]  # Convert to integers to avoid floating point comparison issues
  end
end

class Room
  attr_accessor :matrix, :guard, :visited, :time_loop, :guard_start

  def initialize
    @time_loop = false
    @visited = Set.new
    parse_input_file
    @visited << [@guard.coords, @guard.heading]
  end
  
  def parse_input_file
    @matrix = {}
    File.readlines('input.txt', chomp: true).each_with_index do |line, line_index|
      line.chars.each_with_index do |char, column_index|
        coords = [line_index, column_index]
        if char == '^'
          @guard_start = coords
          @guard = Guard.new(Complex(line_index, column_index))
          @matrix[coords] = '.'
        else
          @matrix[coords] = char
        end
      end
    end
  end

    ....#.....
    .........#
    ..........
    ..#.......
    .......#..
    ..........
    .#..^.....
    ........#.
    #.........
    ......#...

require 'set'

class Guard
  attr_accessor :position, :heading
  def initialize(position)
    self.heading = -1 + 0i
    self.position = position
  end

  def step
    self.position = position + heading
  end

  def turn
    self.heading = Complex(heading.imag, -heading.real)
  end

  def back
    self.position = position - heading
  end

  def coords
    [position.real, position.imag]
  end
end

class Room
  attr_accessor :matrix, :guard, :visited

  def initialize()
    self.visited = Set.new
    self.matrix = File.read('input.txt').lines.each_with_index.flat_map do |line, line_index|
      line.chomp.split('').each_with_index.map do |char, column_index|
        if char == "^"
          self.guard = Guard.new(Complex(line_index, column_index))
          {[line_index, column_index] => '.' }
        else
          {[line_index, column_index] => char }
        end
      end
    end.reduce({}) {|acc, val| acc.merge(val) }
    self.visited << guard.coords
  end

  def step
    guard.step
    if matrix[guard.coords] == "#"
      guard.back
      guard.turn
    end
   
    visited << guard.coords if matrix.key?(guard.coords)
  end

  def run
    step while matrix.key?(guard.coords)
  end
end

room = Room.new
room.run

pp room.visited.length

    ....#.....
    ....+---+#
    ....|...|.
    ..#.|...|.
    ....|..#|.
    ....|...|.
    .#.O^---+.
    ........#.
    #.........
    ......#...

  def initialize()
    self.time_loop = false
    self.visited = Set.new
    self.matrix = File.read('input.txt').lines.each_with_index.flat_map do |line, line_index|
      line.chomp.split('').each_with_index.map do |char, column_index|
        if char == '^'
          self.guard_start = [line_index, column_index]
          self.guard = Guard.new(Complex(line_index, column_index))
          { [line_index, column_index] => '.' }
        else
          { [line_index, column_index] => char }
        end
      end
    end.reduce({}) {|acc, val| acc.merge(val) }

fibonacci = lambda n, a=0, b=1: [a := b, b := a + b][0] if n else None

from functools import lru_cache

fib = lru_cache(None)(lambda n: n if n < 2 else fib(n-1) + fib(n-2))

print(fib(10))  # Output: 55

fib = lambda n, a=0, b=1: a if n == 0 else fib(n-1, b, a+b)

print(fib(10))  # Output: 55

function largerThan(items, start) {
    return items.filter(x => x > start).length;
}

function printTimes(text, aTimes) {
    const times = aTimes ?? 5;
    for (let i=0; i < times; i++) {
        console.count(text);
    }
}

function printTimes(text, times) {
    times ??= 5;
    for (let i=0; i < times; i++) {
        console.count(text);
    }
}

const data = {
    x: { times: 7 },
    y: { times: 2 },
};

const f = (what) => printTimes(what, data[what].times);

f('x');
f('y');

const f = (what) => printTimes(what, data[what]?.times);

f('z');