Data ← 1_2_3_2024
Xor  ← °⋯◿2⬚0+∩⋯ # Bitwise xor of two numbers.
Rng  ← ⊙◌◿,Xor×2048.◿,Xor⌊÷32.◿,Xor×64.⊙16777216
Runs ← ⍉(⇌[⍥(Rng.)])2000 Data # Should be constant?
Firsts ← (
  ⊟⊂0⧈₂/-.◿10 ↘¯1         # Build run, gen pair diffs
  ⊢⧈(⊟⊙⊣/(+×40+20)°⊟) 2_4 # Convert 4-diff into key, collect.
  ⊕⊢⊛⊙⍉⊙◌°⊟.⍉             # Only keep first of each key. # ⍜(map°⊟⍉⇌|∘) failed. 
)
&p /+≡⊣.Runs
&p /↥⊕(/+)+1⊛°⊟⍉/◇⊂wait≡spawn(□Firsts) # Group by key, sum prices, return highest.

  

    
import 'package:collection/collection.dart';
import 'package:more/more.dart';

rng(int i) {
  i = ((i << 6) ^ i) % 16777216;
  i = ((i >> 5) ^ i) % 16777216;
  i = ((i << 11) ^ i) % 16777216;
  return i;
}

Iterable<int> getPrices(int val, int rounds) {
  var ret = [val];
  for (var _ in 1.to(rounds)) {
    ret.add(val = rng(val));
  }
  return ret.map((e) => e % 10);
}

int run(int val, int rounds) => 0.to(rounds).fold(val, (s, t) => s = rng(s));
part1(lines) => [for (var i in lines.map(int.parse)) run(i, 2000)].sum;

part2(List<String> lines) {
  var market = <int, int>{}.withDefault(0);
  for (var seed in lines.map(int.parse)) {
    var seen = <int>{};
    for (var w in getPrices(seed, 2000).window(5)) {
      var key = // Can't use lists as keys, so make cheap hash.
          w.window(2).map((e) => e[1] - e[0]).reduce((s, t) => (s << 4) + t);
      if (seen.contains(key)) continue;
      seen.add(key);
      market[key] += w.last;
    }
  }
  return market.values.max;
}

  

 Go

    
package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
)

type SequenceMap struct {
    Data map[int32]int
}

func PackSeq(numbers [4]int8) int32 {
    var packed int32
    for i, num := range numbers {
        packed |= int32(num+9) << (i * 5)
    }
    return packed
}

func UnpackSeq(packed int32) [4]int8 {
    var numbers [4]int8
    for i := range numbers {
        numbers[i] = int8((packed>>(i*5))&0x1F) - 9
    }
    return numbers
}

func NewSequenceMap() SequenceMap {
    return SequenceMap{make(map[int32]int)}
}

func (m *SequenceMap) Increment(seq [4]int8, val int) {
    pSeq := PackSeq(seq)
    acc, ok := m.Data[pSeq]
    if ok {
        m.Data[pSeq] = acc + val
    } else {
        m.Data[pSeq] = val
    }
}

func (m *SequenceMap) Has(seq [4]int8) bool {
    pSeq := PackSeq(seq)
    _, ok := m.Data[pSeq]
    return ok
}

type Generator struct {
    Secret         int64
    LastPrice      int8
    ChangeSequence []int8
}

func NewGenerator(Secret int64) Generator {
    var ChangeSequence []int8
    return Generator{Secret, int8(Secret % 10), ChangeSequence}
}

func (g *Generator) Mix(value int64) *Generator {
    g.Secret = g.Secret ^ value
    return g
}

func (g *Generator) Prune() *Generator {
    g.Secret = g.Secret % 16777216
    return g
}

func (g *Generator) Next() {
    g.Mix(g.Secret * 64).Prune().Mix(g.Secret / 32).Prune().Mix(g.Secret * 2048).Prune()
    Price := int8(g.Secret % 10)
    g.ChangeSequence = append(g.ChangeSequence, Price-g.LastPrice)
    g.LastPrice = Price
    if len(g.ChangeSequence) > 4 {
        g.ChangeSequence = g.ChangeSequence[1:]
    }
}

func ParseInput() []int64 {
    if fileInfo, _ := os.Stdin.Stat(); (fileInfo.Mode() & os.ModeCharDevice) != 0 {
        fmt.Println("This program expects input from stdin.")
        os.Exit(1)
    }
    scanner := bufio.NewScanner(os.Stdin)

    var numbers []int64
    for scanner.Scan() {
        line := scanner.Text()
        num, err := strconv.ParseInt(line, 10, 64)
        if err != nil {
            fmt.Printf("ERROR PARSING VALUE: %s\n", line)
            os.Exit(1)
        }
        numbers = append(numbers, num)
    }

    return numbers
}

func main() {
    numbers := ParseInput()

    m := NewSequenceMap()
    sum := int64(0)

    for i := 0; i < len(numbers); i += 1 {
        g := NewGenerator(numbers[i])
        tM := NewSequenceMap()
        for j := 0; j < 2000; j += 1 {
            g.Next()
            if len(g.ChangeSequence) == 4 {
                if !tM.Has([4]int8(g.ChangeSequence)) {
                    tM.Increment([4]int8(g.ChangeSequence), 1)
                    if g.LastPrice > 0 {
                        m.Increment([4]int8(g.ChangeSequence), int(g.LastPrice))
                    }
                }
            }
        }
        sum += g.Secret
    }

    fmt.Printf("Part One: %d\n", sum)

    var bestSeq [4]int8
    bestPrice := 0
    for pSeq, price := range m.Data {
        if price > bestPrice {
            bestPrice = price
            bestSeq = UnpackSeq(pSeq)
        }
    }

    fmt.Printf("Part Two: %d\n", bestPrice)
    fmt.Printf("Best Sequence: %d\n", bestSeq)
}

  

    
import Data.Bits
import Data.List
import Data.Map (Map)
import Data.Map qualified as Map

next :: Int -> Int
next = flip (foldl' (\x n -> (x `xor` shift x n) .&. 0xFFFFFF)) [6, -5, 11]

bananaCounts :: Int -> Map [Int] Int
bananaCounts seed =
  let secrets = iterate next seed
      prices = map (`mod` 10) secrets
      changes = zipWith (-) (drop 1 prices) prices
      sequences = map (take 4) $ tails changes
   in Map.fromListWith (const id) $
        take 2000 (zip sequences (drop 4 prices))

main = do
  input <- map read . lines <$> readFile "input22"
  print . sum $ map ((!! 2000) . iterate next) input
  print . maximum $ Map.unionsWith (+) $ map bananaCounts input