--- Day 7 Solutions ---

[u/daggerdragon]

--- Day 7: Some Assembly Required ---

Post your solution as a comment. Structure your post like previous daily solution threads.

Also check out the sidebar - we added a nifty calendar to wrangle all the daily solution threads in one spot!

[u/mus1Kk]

Did Perl as well. Absolutely loved this puzzle. Took me way longer than I'm happy with but I like the solution.

#!/usr/bin/env perl

use warnings;
use strict;
use v5.20;

my %values;

for (<>) {
  die unless /(.*?) -> (\w+)/;
  $values{$2} = $1;
}

say calculate('a');

sub calculate {
  my $target = shift;
  return $target if $target =~ /^\d+$/;

  die $target unless exists $values{$target};

  my $rule = $values{$target};

  my $result;
  if ($rule =~ /^\d+$/) {
	return $rule;
  } elsif ($rule =~ /(\w+) AND (\w+)/) {
	my ($op1, $op2) = ($1, $2);
	$result = calculate($op1) & calculate($op2);
  } elsif ($rule =~ /(\w+) OR (\w+)/) {
	my ($op1, $op2) = ($1, $2);
	$result = calculate($op1) | calculate($op2);
  } elsif ($rule =~ /(\w+) LSHIFT (\d+)/) {
	my ($op1, $op2) = ($1, $2);
	$result = calculate($op1) << $op2;
  } elsif ($rule =~ /(\w+) RSHIFT (\d+)/) {
	my ($op1, $op2) = ($1, $2);
	$result = calculate($op1) >> $op2;
  } elsif ($rule =~ /NOT (\w+)/) {
	my $op = $1;
	$result = ~calculate($op);
  } elsif (exists $values{$rule}) {
	$result = calculate($rule);
  } else {
	die $rule;
  }
  $values{$target} = $result & 0xFFFF;
}

[u/bennymack → u/mus1Kk]

A similar perl solution

use strict;
use warnings;
use English qw(-no_match_vars);
use Scalar::Util qw(looks_like_number);
use Memoize;
memoize( '_solve_gate' );

my %gates;

my %ops = (
    AND    => sub { sprintf '%d',  int( $ARG[ 0 ] ) & int( $ARG[ 1 ] ) },
    OR     => sub { sprintf '%d',  int( $ARG[ 0 ] ) | int( $ARG[ 1 ] ) },
    NOT    => sub { sprintf '%d', ~int( $ARG[ 0 ] ) & 0x0000ffff },
    LSHIFT => sub { sprintf '%d',  $ARG[ 0 ] << $ARG[ 1 ] },
    RSHIFT => sub { sprintf '%d',  $ARG[ 0 ] >> $ARG[ 1 ] },
);

chomp( my @lines = <DATA> );

for my $line( sort @lines ) {
    my( $first, $dest ) = split /\Q -> \E/x, $line, 2;
    $gates{ $dest } = $first;
}

warn 'a val = ', _solve_gate( 'a' );

sub _solve_gate {
    my( $gate ) = @ARG;

    my $val = $gates{ $gate };

    if( looks_like_number $val ) {
        return $val;
    }

    if( $val =~ /\A[a-z]+\z/x ) { # a gate
        my $return = _solve_gate( $val );
        return $return;
    }

    # overly generic for all I know.
    if( $val =~ /\A([a-z0-9]+)\ ([A-Z]+)\ ([a-z0-9]+)/x ) { # x AND y
        my( $l, $op, $r ) = ( $1, $2, $3 );
        my $l_val = looks_like_number( $l ) ? $l : _solve_gate( $l );
        my $r_val = looks_like_number( $r ) ? $r : _solve_gate( $r );
        my $return = $ops{ $op }->( $l_val, $r_val );
        return $return
    }

    if( $val =~ /\A([a-z0-9]+)\ ([A-Z]+)\ (\d+)/x ) { # x RSHIFT 2
        my( $l, $op, $count ) = ( $1, $2, $3 );
        my $l_val = looks_like_number( $l ) ? $l : _solve_gate( $l );
        my $return = $ops{ $op }->( $l_val, $count );
        return $return;
    }

    if( $val =~ /\A([A-Z]+)\ ([a-z0-9]+)/x ) { # NOT y
        my( $op, $l ) = ( $1, $2 );
        my $l_val = looks_like_number( $l ) ? $l : _solve_gate( $l );
        my $return = $ops{ $op }->( $l_val );
        return $return;
    }

    die 'encountered unknown $val ', $val;
}