public Dictionary <TCell, int> Compute(TCell start)
{
var dist = new DefaultDict <TCell, int> {
DefaultValue = int.MaxValue, [start] = 0
};
var seen = new HashSet <TCell>();
var queue = new PriorityQueue <TCell, int>();
queue.Enqueue(start, 0);
while (queue.Count > 0)
{
var cell = queue.Dequeue();
if (seen.Contains(cell))
{
continue;
}
seen.Add(cell);
var current = dist[cell];
foreach (var neighbor in Neighbors(cell))
{
var other = Cell(cell, neighbor);
var weight = Distance(neighbor);
if (!seen.Contains(other))
{
queue.Enqueue(other, current + weight);
}
if (current + weight < dist[other])
{
dist[other] = current + weight;
}
}
}
return(dist);
}
public Dictionary <T, long> Produce(T item, long quantity, out DefaultDict <T, long> extra)
{
extra = new DefaultDict <T, long>();
var count = new DefaultDict <T, long>();
Produce(item, quantity, count, extra);
return(count);
}
// The update function for AI logic.
public void think()
{
if (!Player.humanHasMoved)
{
return;
}
updateHeatmap();
DefaultDict <UnitType, int> currentUnitCounts = new DefaultDict <UnitType, int>(0);
foreach (Unit unit in aiPlayer.units)
{
currentUnitCounts[unit.type] += 1;
}
aiPlayer.tradeWithNClosest(Mathf.Min(8, 1 + currentUnitCounts[UnitType.MERCHANT]));
bool isMaxBuild = true;
foreach (UnitType desiredUnitType in AI_BUILD_ORDER)
{
currentUnitCounts[desiredUnitType] -= 1;
if (currentUnitCounts[desiredUnitType] < 0)
{
isMaxBuild = false;
if (aiPlayer.has(UnitData.getCost(desiredUnitType)))
{
aiPlayer.getBase().trainUnit((int)desiredUnitType);
}
else
{
break;
}
}
}
// Spend excess money on galleys
if (isMaxBuild && aiPlayer.has(UnitData.getCost(UnitType.GALLEY)))
{
aiPlayer.getBase().trainUnit((int)UnitType.GALLEY);
}
/* Warship AI:
* Compute influence heatmap. Move towards threatening enemy warships or weak enemies.
*/
List <Unit> weakEnemies = findWeakEnemies();
// TODO: score weak enemies and other objectives based on distance, influence, etc.
if (weakEnemies.Count > 0)
{
foreach (Unit u in aiPlayer.units)
{
if (u.capableOfAttack())
{
u.moveTo(weakEnemies[0].getPosition(), u.attackRange);
}
}
}
}
public static DefaultDict <TKey, TValue> ToDefaultDict <TKey, TValue> (this IDictionary <TKey, TValue> collection) where TValue : new()
{
var d = new DefaultDict <TKey, TValue>();
foreach (var item in collection)
{
d.Add(item.Key, item.Value);
}
return(d);
}
public SumoSender(string host, int port)
{
this.Host = host;
this.Port = port;
this.seq_ids = new DefaultDict <int, int>();
SumoRemote = new IPEndPoint(IPAddress.Parse(host), port);
sumoSocket = new UdpClient();
// Initial command (no motion)
this.cmd = SumoCommandsCustom._pack_frame(SumoCommandsCustom.Move_cmd(0, 0));
}
public override void PartOne()
{
var reg = new DefaultDict <string, int>();
foreach (var(r, sign, offset, cmp, op, value) in GetInput())
{
if (op.Operation(reg[cmp], value))
{
reg[r] += sign.Inc ? offset : -offset;
}
}
WriteLn(reg.Values.Max());
}
/// <summary>
/// Construct a basic server such that it is ready to be started, and possibly using the default connect
/// behavior.
/// </summary>
public BasicServer(IPAddress localaddr, int port, string logFileName = null, bool tailLog = true)
{
IsRunning = false;
_localaddr = localaddr;
_port = port;
ClientTable = new BidirectionalDict<string, Client>();
AuthTable = new DefaultDict<Client, bool>();
Log = new FileLog(logFileName, Frequency.Burst);
if (tailLog)
Log.AddMirror(new ConsoleLog());
Log.Info("Server initialized: <{0}>::{1}".format(localaddr, port));
}
private void Produce(T item, long quantity, DefaultDict <T, long> count, DefaultDict <T, long> extra)
{
if (!TryGet(item, out var vertex))
{
throw new Exception("Cannot produce needed item.");
}
long willProduce;
var scale = 1L;
if (vertex.Quantity == 0 && vertex.Count != 0)
{
throw new Exception("Only 0 of the item can be made.");
}
if (vertex.Quantity == 0)
{
willProduce = quantity;
}
else
{
willProduce = quantity % vertex.Quantity == 0 ? quantity : quantity + (vertex.Quantity - (quantity % vertex.Quantity));
scale = willProduce / vertex.Quantity;
}
foreach (var(child, amount) in vertex.Produced())
{
var want = amount * scale;
var piece = child.Value;
extra.TryGetValue(piece, out var have);
if (have > want)
{
count[piece] += want;
extra[piece] -= want;
}
else if (have == want)
{
count[piece] += want;
extra.Remove(piece);
}
else
{
count[piece] += have;
extra.Remove(piece);
Produce(piece, want - have, count, extra);
}
}
count[item] += quantity;
if (willProduce > quantity)
{
extra[item] += willProduce - quantity;
}
}
public override void PartTwo()
{
var reg = new DefaultDict <string, int>();
var max = 0;
foreach (var(r, sign, offset, cmp, op, value) in GetInput())
{
if (op.Operation(reg[cmp], value))
{
reg[r] += sign.Inc ? offset : -offset;
max = Math.Max(max, reg[r]);
}
}
WriteLn(max);
}
/// <summary>
/// Find the node with the lowest F score.
/// </summary>
private static Node FindLowestFScore(HashSet <Node> openSet, Node current, DefaultDict fScore)
{
var lowest = float.MaxValue;
Node selectedNode = current;
foreach (var node in openSet)
{
if (fScore.Get(node) < lowest)
{
selectedNode = node;
lowest = fScore.Get(node);
}
}
return(selectedNode);
}
public long ProduceFrom(T item, Dictionary <T, long> have)
{
var made = new DefaultDict <T, long>();
var extra = new DefaultDict <T, long>(have);
long count = 0;
while (true)
{
Produce(item, 1, made, extra);
if (have.Any(pair => made[pair.Key] > pair.Value))
{
break;
}
count++;
}
return(count);
}
public override string Part1()
{
var eris = new Eris(ReadAllText(), false, 0);
var set = new DefaultDict <int, int>();
while (true)
{
var r = eris.Rating();
set[r]++;
if (set[r] > 1)
{
return(r.ToString());
}
eris.Tick();
eris.Swap();
}
}
public BigInteger Compute(int times)
{
var counts = AllGroups[0][0].Window(2).StrEach().Frequencies().SelectValue(i => (BigInteger)i).ToDictionary();
var map = AllGroups[1].ReadKeys("->");
for (var i = 0; i < times; i++)
{
var next = new DefaultDict <string, BigInteger>();
foreach (var(pair, count) in counts)
{
var add = map[pair];
next[pair[0] + add] += count;
next[add + pair[1]] += count;
}
counts = next;
}
var freq = new DefaultDict <char, BigInteger>();
freq[AllGroups[0][0][^ 1]]++; // Account for possible off-by-one
public PresetTextLesson(string text, int maxLength = 0)
{
if (maxLength == 0)
{
maxLength = defaultLessonLength;
}
text = text.Trim();
alphabet = text.ToUpper().ToHashSet();
characterFrequencyCount = new DefaultDict <char, int>();
foreach (char c in text.ToUpper())
{
characterFrequencyCount[c] += 1;
}
queuedTexts = new List <string>();
//TODO:
//Divide up the text into about to equal chunks, each of which is smaller than maxLength
int start = 0;
int remaining = text.Length;
do
{
double chunks = Math.Ceiling((double)remaining / maxLength);
int targetLength = (int)Math.Ceiling(remaining / chunks);
int chunklength = text.Substring(start, targetLength).LastIndexOf(" ");
if (chunklength == -1) //word is too long; chop it up
{
chunklength = start + maxLength;
}
// .Substring complains about going over the length
queuedTexts.Add(text.Substring(start, Math.Min(chunklength, remaining)));
start += chunklength + 1;
remaining = text.Length - start;
} while (remaining > 0);
}
long OreRequired(string what, long count, DefaultDict <string, long> stock)
{
if (what == "ORE")
{
return(count);
}
if (stock[what] > 0)
{
var howMuchWeCanUse = Math.Min(count, stock[what]);
stock[what] -= howMuchWeCanUse;
count -= howMuchWeCanUse;
}
if (count == 0)
{
return(0);
}
var item = ReadInput().Single(x => x.Output.Name == what);
var react = 1L;
if (count > item.Output.Count)
{
react = (long)Math.Ceiling((double)count / item.Output.Count);
}
stock[what] += react * item.Output.Count - count;
var ore = 0L;
foreach (var n in item.Input)
{
ore += OreRequired(n.Name, react * n.Count, stock);
}
return(ore);
}
/// <param name="dictonary">List of words the generator can use</param>
/// <param name="maxLength">Exclusive maximum length of each generated text chunk</param>
public RandomizedLesson(IEnumerable <string> dictonary, int maxLength = 0)
{
if (maxLength == 0)
{
maxLength = defaultLessonLength;
}
dict = Sanitize(dictonary);
chunkLength = maxLength;
random = NextRandom();
place = 0;
shuffled = dict.OrderBy(x => random.Next()).ToList();
//all characters which appear at least 50 times in the dictionary
alphabet = dict.SelectMany(x => x.ToUpper()).GroupBy(x => x).Where(x => x.Count() > 50).SelectMany(x => x).ToHashSet();
characterFrequencyCount = new DefaultDict <char, int>();
foreach (char c in dictonary.SelectMany(w => w.ToUpper().ToCharArray()))
{
characterFrequencyCount[c] += 1;
}
NextText();
}
public SeriesData GenerateSeries(IList<ProcessedInfo> infos)
{
bool isTrackingExes = Settings.Options.TrackExes;
infos = infos.OrderBy(i => i.Time).ToList();
double minTime = infos[0].Time;
double totalTime = infos[infos.Count - 1].Time - infos[0].Time;
if (totalTime < 0)
{
throw new Exception("backwards sort");
}
var allNames = new HashSet<string>();
var all = new List<IDictionary<string, double>>();
var next = new DefaultDict<string, double>();
double time = minTime;
double timeSpan;// = totalTime / partitions;
timeSpan = 60 * 14.4; //one percent hour
if (timeSpan > updateFrequency)
{
timeSpan = updateFrequency;
}
foreach (var info in infos)
{
if (info.Program.Categories.Count != 0)
{
allNames.Add(info.Program.Categories[categoryIndex]);
}
}
double lastTime = time;
double lastActiveTime = -1;
foreach (var info in infos)
{
if (info.DidActivity || lastActiveTime < 0)
{
lastActiveTime = lastTime;
}
string key;
if (info.Time - lastActiveTime > Settings.Options.IdleTime)
{
var program = ProgramInfo.Idle;
allNames.Add(program.Name);
key = program.Name;
}
else
{
try
{
key = info.Program.Categories[categoryIndex];
}
catch
{
key = "Neutral";
}
}
next[key] += info.Time - lastTime;
lastTime = info.Time;
if (info.Time - time > timeSpan)
{
time = info.Time;
all.Add(next);
next = new DefaultDict<string, double>();
}
}
return new SeriesData(all.Select(normalize).ToList(), allNames, timeSpan);
}
void Network()
{
var tasks = new List <Task>();
using var abort = new ManualResetEvent(false);
var lan = new IntCodeComputer[N];
var hub = new ConcurrentDictionary <long, List <Packet> >();
var buf = new ConcurrentDictionary <long, List <long> >();
var init = new bool[N];
for (int i = 0; i < N; i++)
{
var ip = i;
var c = new IntCodeComputer(ReadAllText().ToIntCode());
c.SignalOutput += _output =>
{
if (abort.WaitOne(10))
{
c.Terminate();
}
buf[ip].Add(_output);
if (buf[ip].Count == 3)
{
var packet = new Packet()
{
IP = buf[ip][0],
X = buf[ip][1],
Y = buf[ip][2],
SentX = false
};
if (packet.IP == 255 && _part1 == 0)
{
_part1 = packet.Y;
}
lock (this)
{
hub[packet.IP].Add(packet);
}
buf[ip].Clear();
}
};
c.ProvideInput += () =>
{
if (abort.WaitOne(10))
{
c.Terminate();
}
if (init[ip])
{
if (hub[ip].Any())
{
Packet p;
lock (this)
{
p = hub[ip][0];
if (p.SentX)
{
hub[ip].RemoveAt(0);
}
}
if (p.SentX)
{
return(p.Y);
}
else
{
p.SentX = true;
return(p.X);
}
}
return(-1);
}
else
{
init[ip] = true;
return(ip);
}
};
lan[i] = c;
buf[i] = new List <long>();
hub[i] = new List <Packet>();
hub[255] = new List <Packet>();
tasks.Add(new Task(c.Run));
}
tasks.Add(new Task(NAT));
tasks.ForEach(x => x.Start());
Task.WhenAll(tasks).ConfigureAwait(false).GetAwaiter().GetResult();
void NAT()
{
while (!init.All(x => x))
{
Thread.Sleep(100);
}
var sent = new DefaultDict <long, int>();
while (true)
{
Thread.Sleep(100);
List <(long Key, int Count)> queues;
lock (this)
{
queues = hub.Where(kv => kv.Key != 255).Select(kv => (kv.Key, kv.Value.Count)).ToList();
}
if (queues.All(item => item.Count == 0) && hub[255].Any())
{
Packet last;
lock (this)
{
last = hub[255].Last();
hub[255].Clear();
}
sent[last.Y]++;
if (sent[last.Y] == 2)
{
_part2 = last.Y;
abort.Set();
return;
}
lock (this)
{
hub[0].Add(last);
}
}
}
}
}
/// <summary>
/// Find the path from start to goal using the A* algorithm. Based on the Wikipedia pseudo code example:
/// https://en.wikipedia.org/wiki/A*_search_algorithm#Pseudocode
/// </summary>
/// <returns><c>true</c>, if path was found, <c>false</c> otherwise.</returns>
public static bool FindPath(Node start, Node goal)
{
var closedSet = new HashSet <Node> ();
var openSet = new HashSet <Node> ();
openSet.Add(start);
var gScore = new DefaultDict();
gScore.Set(start, 0);
var fScore = new DefaultDict();
fScore.Set(start, HeuristicEstimate(start, goal));
var cameFrom = new Dictionary <Node, Node> ();
Node current = start;
while (openSet.Count > 0)
{
current = FindLowestFScore(openSet, current, fScore);
if (current.Type != Node.NodeType.Start && current.Type != Node.NodeType.Goal)
{
current.Type = Node.NodeType.Explored;
}
if (current == goal)
{
ReconstructPath(cameFrom, current);
return(true);
}
openSet.Remove(current);
closedSet.Add(current);
foreach (var neighbor in current.Connections.Keys)
{
if (closedSet.Contains(neighbor))
{
continue;
}
if (!openSet.Contains(neighbor))
{
openSet.Add(neighbor);
}
var tentativeGScore = gScore.Get(current) + current.Connections [neighbor];
if (tentativeGScore >= gScore.Get(neighbor))
{
continue;
}
cameFrom [neighbor] = current;
gScore.Set(neighbor, tentativeGScore);
fScore.Set(neighbor, gScore.Get(neighbor) + HeuristicEstimate(neighbor, goal));
}
}
return(false);
}
private static IDictionary<string, double> normalize(IDictionary<string, double> map)
{
var result = new DefaultDict<string, double>();
var total = map.Values.Sum();
foreach(var pair in map)
{
result[pair.Key] = pair.Value/total;
}
return result;
}
