public static void Solve(Stream stdin, Stream stdout)
{
var scanner = new OptimizedPositiveIntReader(stdin);
var writer = new BufferedStdoutWriter(stdout);
for (long i = 1; i < 50000; i++)
{
tab.Add(i * (i + 1));
}
var p = scanner.NextLong();
var q = scanner.NextLong();
while (q != 0)
{
var result = Calculate(p, q);
writer.Write(result);
writer.Write("\n");
p = scanner.NextLong();
q = scanner.NextLong();
}
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
IScanner scanner = new OptimizedPositiveIntReader(stdin);
// uncomment when you need more advanced reader
// IScanner scanner = new Scanner(stdin);
// IScanner scanner = new LineReader(stdin);
var writer = new BufferedStdoutWriter(stdout);
var fizz = scanner.NextInt();
var buzz = scanner.NextInt();
var n = scanner.NextInt();
for (int i = 1; i <= n; i++)
{
if (i % fizz == 0)
{
writer.Write("Fizz");
}
if (i % buzz == 0)
{
writer.Write("Buzz");
}
if (i % fizz != 0 && i % buzz != 0)
{
writer.Write(i.ToString());
}
writer.Write("\n");
}
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
IScanner scanner = new OptimizedPositiveIntReader(stdin);
var writer = new BufferedStdoutWriter(stdout);
var n = scanner.NextInt();
for (int i = 0; i < n; i++)
{
var nodeCount = scanner.NextInt();
var desired = scanner.NextInt() != 0;
var nodes = new Node[nodeCount];
for (int j = 0; j < (nodeCount - 1) / 2; j++)
{
nodes[j] = new Node {
Type = scanner.NextInt() == 1 ? Gate.And : Gate.Or, Changable = scanner.NextInt() != 0
};
}
for (int j = (nodeCount - 1) / 2; j < nodeCount; j++)
{
nodes[j] = new Node {
IsLeaf = true, LeafValue = scanner.NextInt() != 0
};
}
var tree = new NodeRef(nodes);
var result = tree.MinChanges(desired);
writer.Write("Case #" + (i + 1) + ": " + (result == int.MinValue ? "IMPOSSIBLE" : result.ToString()) + "\n");
}
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
//IScanner scanner = new OptimizedPositiveIntReader(stdin);
// uncomment when you need more advanced reader
IScanner scanner = new Scanner(stdin);
// IScanner scanner = new LineReader(stdin);
var writer = new BufferedStdoutWriter(stdout);
var n = scanner.NextInt();
var list = new Dictionary <int, string>();
for (int i = 0; i < n; i++)
{
var pierwszy = scanner.Next();
var drugi = scanner.Next();
if (pierwszy[0] > 'a' && pierwszy[0] < 'z')
{
list.Add(int.Parse(drugi) * 2, pierwszy);
}
else
{
list.Add(int.Parse(pierwszy), drugi);
}
}
foreach (var keyValuePair in list.OrderBy(pair => pair.Key))
{
writer.Write(keyValuePair.Value);
writer.Write("\n");
}
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
IScanner scanner = new LineReader(stdin);
// uncomment when you need more advanced reader
// IScanner scanner = new Scanner(stdin);
// IScanner scanner = new LineReader(stdin);
var writer = new BufferedStdoutWriter(stdout);
int n = 0;
int set = 0;
while ((n = scanner.NextInt()) != 0)
{
if (set != 0)
{
writer.Write("\n");
}
var arr = new SortedSet <string>(new mycomp());
for (int i = 0; i < n; i++)
{
arr.Add(scanner.Next());
}
foreach (var s in arr)
{
writer.Write(s + "\n");
}
set++;
}
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
IScanner scanner = new OptimizedPositiveIntReader(stdin);
// uncomment when you need more advanced reader
// IScanner scanner = new Scanner(stdin);
// IScanner scanner = new LineReader(stdin);
var writer = new BufferedStdoutWriter(stdout);
var dog1Aggresive = scanner.NextInt();
var dog1Calm = scanner.NextInt();
var dog2Aggresive = scanner.NextInt();
var dog2Calm = scanner.NextInt();
var postman = scanner.NextInt();
var milkman = scanner.NextInt();
var garbageman = scanner.NextInt();
GetValue(postman, dog1Aggresive, dog1Calm, dog2Aggresive, dog2Calm, writer);
GetValue(milkman, dog1Aggresive, dog1Calm, dog2Aggresive, dog2Calm, writer);
GetValue(garbageman, dog1Aggresive, dog1Calm, dog2Aggresive, dog2Calm, writer);
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
IScanner scanner = new OptimizedPositiveIntReader(stdin);
// uncomment when you need more advanced reader
// scanner = new Scanner(stdin);
// scanner = new LineReader(stdin);
var writer = new BufferedStdoutWriter(stdout);
var n = scanner.NextInt();
var a = new int[n];
var b = new int[n];
for (var i = 0; i < n; i++)
{
a[i] = scanner.NextInt();
}
for (var i = 0; i < n; i++)
{
b[i] = scanner.NextInt();
}
var result = SolutionCompacting(a, b);
writer.Write(result);
writer.Write("\n");
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
IScanner scanner = new Scanner(stdin);
// uncomment when you need more advanced reader
// IScanner scanner = new Scanner(stdin);
// IScanner scanner = new LineReader(stdin);
writer = new BufferedStdoutWriter(stdout);
int n = scanner.NextInt();
while (n-- > 0)
{
int k = scanner.NextInt();
var arr = new int[k];
for (int i = 0; i < k; i++)
{
arr[i] = scanner.NextInt();
}
type(k, arr);
}
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
IScanner scanner = new Scanner(stdin);
var writer = new BufferedStdoutWriter(stdout);
var list = new List <BigInteger>();
var count = scanner.NextInt();
BigInteger total = new BigInteger(0);
for (uint i = 0; i < count; i++)
{
string password = scanner.Next();
list.Add(ToInt(scanner.Next()));
}
list.Sort();
list.Reverse();
for (int i = 0; i < list.Count; i++)
{
var multiplier = new BigInteger(i + 1);
total += multiplier * list[i];
}
writer.Write(format(total));
writer.Write("\n");
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
IScanner scanner = new OptimizedPositiveIntReader(stdin);
var writer = new BufferedStdoutWriter(stdout);
var input = scanner.NextInt();
writer.Write(input * (input - 1) * (input - 2) * (input - 3) / 24);
writer.Write("\n");
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
IScanner scanner = new OptimizedPositiveIntReader(stdin);
// uncomment when you need more advanced reader
scanner = new Scanner(stdin);
// scanner = new LineReader(stdin);
var writer = new BufferedStdoutWriter(stdout);
var numberOfTestCases = scanner.NextInt();
for (var i = 0; i < numberOfTestCases; i++)
{
BigInteger x1 = scanner.NextInt();
BigInteger y1 = scanner.NextInt();
var operation = scanner.Next();
BigInteger x2 = scanner.NextInt();
BigInteger y2 = scanner.NextInt();
Tuple <BigInteger, BigInteger> result;
switch (operation)
{
case "+":
result = Add(x1, y1, x2, y2);
break;
case "-":
// to substract is like to add but with the oposite sign
result = Add(x1, y1, -x2, y2);
break;
case "*":
result = Multiply(x1, y1, x2, y2);
break;
case "/":
// to divide is like to multiple by the oposite
result = Multiply(x1, y1, y2, x2);
break;
default:
throw new InvalidOperationException("no operation for:" + operation);
}
writer.Write(result.Item1);
writer.Write(" / ");
writer.Write(result.Item2);
writer.Write("\n");
}
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
IScanner scanner = new OptimizedPositiveIntReader(stdin);
var writer = new BufferedStdoutWriter(stdout);
var n = scanner.NextInt();
var costs = new int[n + 1]; //COST OD DOOR i to i+1
var inimalCosts = new int[n + 1]; //MINIMAL COST BEFORE DOOR N
var times = new int[n];
for (int j = 1; j <= n - 1; j++)
{
costs[j] = scanner.NextInt();
if (j == 1)
{
inimalCosts[j] = costs[j];
}
else
{
inimalCosts[j] = Math.Min(inimalCosts[j - 1], costs[j]);
}
}
for (int j = 0; j < n; j++)
{
times[j] = scanner.NextInt();
}
int currentTime = 0; //current time
int i = 0;
long totalCost = 0;
while (i < n - 1)
{
i++;
currentTime++;
totalCost += costs[i];
int nextGateOpen = times[i] - currentTime;
while (nextGateOpen > 0)
{
nextGateOpen -= 2;
totalCost += inimalCosts[i] * 2;
currentTime += 2;
}
}
writer.Write(totalCost + "\n");
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
IScanner scanner = new OptimizedPositiveIntReader(stdin);
// uncomment when you need more advanced reader
// IScanner scanner = new Scanner(stdin);
// IScanner scanner = new LineReader(stdin);
var writer = new BufferedStdoutWriter(stdout);
var input = scanner.NextInt();
writer.Write(input * 5);
writer.Write("\n");
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
if (Log == null)
{
Log = (msg) => Console.WriteLine(msg);
}
Log("Solving <%= problem %>. https://open.kattis.com/problems/<%= problem %>");
//IScanner scanner = new OptimizedPositiveIntReader(stdin);
// uncomment when you need more advanced reader
// IScanner scanner = new Scanner(stdin);
IScanner scanner = new LineReader(stdin);
var writer = new BufferedStdoutWriter(stdout);
var input = scanner.Next();
Log($"Input: {input}");
writer.Write("answer");
writer.Write("\n");
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
// IScanner scanner = new OptimizedPositiveIntReader(stdin);
// uncomment when you need more advanced reader
// IScanner scanner = new Scanner(stdin);
IScanner scanner = new LineReader(stdin);
var writer = new BufferedStdoutWriter(stdout);
var regex = new Regex("0[xX][\\da-fA-F]+");
string input = scanner.Next();
while (input != null)
{
var match = regex.Match(input);
while (match.Success)
{
UInt64 hex;
bool parsed = UInt64.TryParse(match.Value.Substring(2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out hex);
if (parsed)
{
writer.Write(match.Value);
writer.Write(" ");
writer.Write(hex);
writer.Write("\n");
}
match = match.NextMatch();
}
input = scanner.Next();
}
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
IScanner scanner = new OptimizedPositiveIntReader(stdin);
var writer = new BufferedStdoutWriter(stdout);
var n = scanner.NextInt();
var m = scanner.NextInt();
_timeTable = new int[n, m];
for (int i = 0; i < n; i++)
{
for (int j = 0; j < m; j++)
{
_timeTable[i, j] = scanner.NextInt();
}
}
var stages = new int[m];
_pending = new List <Status>();
for (int i = 0; i < n; i++)
{
_pending.Add(new Status());
}
stages[0] = _timeTable[0, 0];
_pending[0].Stage = 0;
_pending[0].TimeLeft = _timeTable[0, 0];
// var finished = 0;
// var totalTime = 0;
// var maxStage = 0;
/* while (finished < n)
* {
* var time = GetMin(stages);
* totalTime += time;
*
* for (int i = 0; i < stages.Length; i++)
* {
* stages[i] = Math.Max(0, stages[i] - time);
* }
*
* for (int i = finished; i < _pending.Count; i++)
* {
* _pending[i].Wait(time);
* if (_pending[i].TimeLeft == 0 && _pending[i].Stage == m-1)
* {
* _pending[i].TotalTime = totalTime;
* finished++;
* }
* else if (_pending[i].TimeLeft == 0 && NexStageIsFree(stages, _pending[i].Stage))
* {
* var nextStage = _pending[i].Stage + 1;
* if (nextStage > maxStage)
* maxStage = nextStage;
*
* _pending[i].Stage = nextStage;
* _pending[i].TimeLeft = _timeTable[i, nextStage];
* stages[nextStage] = _timeTable[i, nextStage];
* }
* }
* }*/
for (int i = 0; i < n; i++)
{
for (int j = 0; j < m; j++)
{
var time = _timeTable[i, j];
var left = (j - 1 < 0) ? 0 : _timeTable[i, j - 1];
var up = (i - 1 < 0) ? 0 : _timeTable[i - 1, j];
var add = Math.Max(left, up);
_timeTable[i, j] += add;
}
}
/*
* var times = new int[n];
* var maxN = 0;
* var maxM = 0;
* var next = _timeTable[0, 0];
*
* var elapsed = _timeTable[0, 0];
* times[0] += _timeTable[0, 0];
*
* while (true)
* {
* for (int i = 0; i <= maxM; i++)
* {
* for (int j = 0; j < maxN; j++)
* {
*
*
* }
* }
* }
*/
for (int i = 0; i < n; i++)
{
writer.Write(_timeTable[i, m - 1]);
if (i < n - 1)
{
writer.Write(" ");
}
}
//var output = string.Join(" ", _timeTable.Select(status => status.TotalTime));
// writer.Write(output);
writer.Write("\n");
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
IScanner scanner = new OptimizedPositiveIntReader(stdin);
// uncomment when you need more advanced reader
// IScanner scanner = new Scanner(stdin);
// IScanner scanner = new LineReader(stdin);
var writer = new BufferedStdoutWriter(stdout);
var x = scanner.NextInt();
var y = scanner.NextInt();
var x2 = 0.0;
var y2 = 0.0;
if (x == 0)
{
if (y < 125)
{
x2 = 15625.0 * 2 / (250 - y);
y2 = 250 - x2;
}
else if (y > 125)
{
x2 = 15625.0 * 2 / y;
y2 = 0;
}
else
{
x2 = 250;
y2 = 0;
}
}
else if (y == 0)
{
if (x < 125)
{
y2 = 15625.0 * 2 / (250 - x);
x2 = 250 - y2;
}
else if (x > 125)
{
y2 = 15625.0 * 2 / x;
x2 = 0;
}
else
{
x2 = 0;
y2 = 250;
}
}
else
{
if (x > 125)
{
y2 = 250.0 - 15625.0 * 2 / x;
x2 = 0;
}
else if (y > 125)
{
x2 = 250.0 - 15625.0 * 2 / y;
y2 = 0;
}
else
{
x2 = 0;
y2 = 0;
}
}
writer.Write(x2.ToString("0.00") + " " + y2.ToString("0.00"));
writer.Write("\n");
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
IScanner scanner = new OptimizedPositiveIntReader(stdin);
// uncomment when you need more advanced reader
// scanner = new Scanner(stdin);
scanner = new LineReader(stdin);
var writer = new BufferedStdoutWriter(stdout);
var testCases = scanner.NextInt();
for (int i = 0; i < testCases; i++)
{
var line = scanner.Next();
var result = 0;
int stringNotCovered = line.Length;
for (int j = 1; j < line.Length; j++)
{
if (line.Substring(0, j).StartsWith(line.Substring(j, Math.Min(line.Length - j, j))))
{
// if (result == 0)
// {
// result = j;
// break;
// }
if (result == 0)
{
result = j;
int k = j;
while (k + result < line.Length && line.Substring(k, result) == line.Substring(0, j))
{
k += result;
}
stringNotCovered = line.Length - k - j;
}
else if (result != 0 && j % result == 0)
{
// ignore - we already handled it
}
else
{
// we already have a solution, just check if it covers more ground
// this one doesn't repeat itself
if (stringNotCovered > 0 && 2 * j > line.Length - stringNotCovered)
{
result = j;
stringNotCovered = 0;
break;
}
}
}
}
writer.Write(result);
writer.Write("\n");
}
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
IScanner scanner = new OptimizedPositiveIntReader(stdin);
// uncomment when you need more advanced reader
// IScanner scanner = new Scanner(stdin);
// IScanner scanner = new LineReader(stdin);
var writer = new BufferedStdoutWriter(stdout);
while (true)
{
int n = scanner.NextInt();
if (n == 0)
{
break;
}
List <Corner> c = new List <Corner>(n);
for (int i = 0; i < n; i++)
{
c.Add(new Corner(scanner.NextInt(), scanner.NextInt()));
}
List <double> angles = new List <double>(n);
update(c, angles);
double uniMin = 0;
Corner lastRemoved = new Corner(0, 0);
int lastMinIndex = 0;
while (true)
{
double min = Double.MaxValue;
int minIndex = 0;
for (int i = 0; i < angles.Count; i++)
{
if (angles[i] < min)
{
min = angles[i];
minIndex = i;
}
}
if (min < uniMin)
{
c.Insert(lastMinIndex, lastRemoved);
break;
}
if (angles.Count == 3)
{
break;
}
lastRemoved = c[minIndex];
c.RemoveAt(minIndex);
uniMin = min;
lastMinIndex = minIndex;
update(c, angles);
}
writer.Write(c.Count + " " + string.Join(" ", c.Select(corner => corner.x + " " + corner.y)) + "\n");
}
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
IScanner scanner = new OptimizedPositiveIntReader(stdin);
var writer = new BufferedStdoutWriter(stdout);
var n = scanner.NextInt();
var h = scanner.NextInt();
var l = scanner.NextInt();
var hi = new int [n];
var connection = new Dictionary <int, HashSet <int> >(n);
for (int i = 0; i < n; i++)
{
hi[i] = int.MaxValue - 1;
connection[i] = new HashSet <int>();
}
Queue <int> toProcess = new Queue <int>();
for (int i = 0; i < h; i++)
{
var movieIndex = scanner.NextInt();
hi[movieIndex] = 0;
toProcess.Enqueue(movieIndex);
}
for (int i = 0; i < l; i++)
{
var m1 = scanner.NextInt();
var m2 = scanner.NextInt();
connection[m1].Add(m2);
connection[m2].Add(m1);
}
while (toProcess.Count > 0)
{
var movie = toProcess.Dequeue();
var connections = connection[movie];
foreach (var other in connections)
{
hi[other] = Math.Min(hi[movie] + 1, hi[other]);
connection[other].Remove(movie);
if (connection[other].Count > 0)
{
toProcess.Enqueue(other);
}
}
connections.Clear();
}
int maxi = 0;
int max = hi[0];
for (int i = 0; i < n; i++)
{
if (hi[i] > max)
{
maxi = i;
max = hi[i];
}
}
writer.Write(maxi);
writer.Write("\n");
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
IScanner scanner = new Scanner(stdin);
var writer = new BufferedStdoutWriter(stdout);
var left = new BinaryHeap <int>(100000, new MinComparer().Compare);
var right = new BinaryHeap <int>(100000, new MaxComparer().Compare);
while (scanner.HasNext())
{
var next = scanner.Next();
if (next == "#")
{
int cookie;
if (left.Size > right.Size)
{
cookie = left.Pop();
}
else
{
cookie = right.Pop();
}
writer.Write(cookie + "\n");
}
else
{
var d = int.Parse(next);
if (left.Size == 0)
{
left.Insert(d);
continue;
}
var maxleft = left.Peak();
if (d <= maxleft)
{
left.Insert(d);
}
else
{
right.Insert(d);
}
if (right.Size > left.Size + 1)
{
var minright = right.Pop();
left.Insert(minright);
}
else if (left.Size > right.Size + 1)
{
maxleft = left.Pop();
right.Insert(maxleft);
}
}
}
writer.Flush();
}
public static void Solve(Stream stdin, Stream stdout)
{
IScanner scanner = new Scanner(stdin);
var writer = new BufferedStdoutWriter(stdout);
var testcases = scanner.NextInt();
var dic = new Dictionary <string, int>();
var groups = new List <HashSet <string> >(0);
for (int i = 0; i < testcases; i++)
{
var pairs = scanner.NextInt();
for (int j = 0; j < pairs; j++)
{
var p1 = scanner.Next();
var p2 = scanner.Next();
int g1 = -1;
int g2 = -2;
if (!dic.TryGetValue(p1, out g1))
{
g1 = -1;
}
if (!dic.TryGetValue(p2, out g2))
{
g2 = -1;
}
if (g1 == -1 && g2 == -1)
{
groups.Add(new HashSet <string>(new[] { p1, p2 }));
dic[p1] = dic[p2] = groups.Count - 1;
}
else if (g1 == -1)
{
dic[p1] = g2;
groups[g2].Add(p1);
}
else if (g2 == -1)
{
dic[p2] = g1;
groups[g1].Add(p2);
}
else if (g1 != g2)
{
var group2 = groups[g2];
dic[p2] = g1;
foreach (var name in group2)
{
dic[name] = g1;
groups[g1].Add(name);
}
group2.Clear();
}
var finalg = dic[p1];
writer.Write(groups[finalg].Count);
writer.Write("\n");
}
dic.Clear();
groups.Clear();
}
writer.Flush();
}
