public void GetAreasUsed(BigList <long> usedAreas)
{
usedAreas.Add(headerAreaId);
for (int i = 0; i < BlockCount; ++i)
{
usedAreas.Add(blockElements[i]);
}
}
internal void GetAreasUsed(BigList <long> list)
{
list.Add(startArea.Id);
list.Add(indexHeaderPointer);
foreach (var block in indexBlocks)
{
list.Add(block.StartOffset);
long[] blockPointers = block.GetBlockPointers();
list.AddRange(blockPointers);
}
}
public static void InsertSort()
{
var index = new SortedCollection <SqlObject, long>();
var items = new BigList <SqlObject>();
items.Add(SqlObject.Integer(435));
items.Add(SqlObject.Integer(1920));
var comparer = new CollectionComparer(items);
index.InsertSort(SqlObject.Double(2234.99), 45, comparer);
Assert.Equal(1, index.Count);
}
static void Main(string[] args)
{
var asd = new BigList <int>();
asd.Add(0);
asd.Add(1);
asd.Add(2);
asd.Add(3);
asd.Insert(50, 10);
foreach (var item in asd)
{
Console.WriteLine(item);
}
}
/// <summary>
/// Opens a new generation in this GSS
/// </summary>
/// <returns>The index of the new generation</returns>
public int CreateGeneration()
{
nodeGenerations.Add(new GSSGeneration(nodeLabels.Size));
edgeGenerations.Add(new GSSGeneration(edges.Size));
generation++;
return(generation);
}
static void Main(string[] args)
{
string nextLine;
string[] splitText;
var numbers = new BigList <int>();
while ((nextLine = Console.ReadLine()) != "EXIT")
{
splitText = nextLine.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
switch (splitText[0])
{
case "ADD":
var num = int.Parse(splitText[1]);
numbers.Add(num);
break;
case "FIND":
FindCommand(numbers);
break;
}
}
Console.Write(sb.ToString());
}
public TableIndex Subset(ITable table, int[] columns)
{
if (table == null)
{
throw new ArgumentNullException(nameof(table));
}
if (columns.Length > 1)
{
throw new NotSupportedException("multi-columns subset not implemented yet");
}
// Resolve table rows in this table scheme domain.
var rowSet = new BigList <long>(table.RowCount);
foreach (var row in table)
{
rowSet.Add(row.Number);
}
var rows = table.ResolveRows(columns[0], rowSet, Table);
// Generates an IIndex which contains indices into 'rowSet' in
// sorted order.
var newSet = OrderRows(rows).ToBigArray();
// Our 'new_set' should be the same size as 'rowSet'
if (newSet.Length != rowSet.Count)
{
throw new Exception("Internal sort error in finding sub-set.");
}
return(CreateSubset(table, columns[0], newSet));
}
private IEnumerable <long> GetMaxFromEachGroup(int colNum)
{
var refTab = table;
var extractRows = new BigList <long>();
var size = groupLinks.Count;
for (int i = 0; i < size; ++i)
{
var group = groupLinks[i];
SqlObject max = null;
long toTakeInGroup = -1;
for (int j = 0; j < group.Count; j++)
{
var groupRow = group[j];
var value = refTab.GetValue(groupRow, colNum);
if (max == null || value.CompareTo(max) > 0)
{
max = value;
toTakeInGroup = groupRow;
}
}
extractRows.Add(toTakeInGroup);
}
return(extractRows);
}
public static void Editor()
{
var text = new BigList<string> ();
string command = " ";
do {
command = Console.ReadLine();
var parts = command.Split(' ');
switch( parts[0]) {
case "INSERT":
text.Add(parts[1]);
Console.WriteLine("OK");
break;
case "APPEND":
text.AddToFront(parts[1]);
Console.WriteLine("OK");
break;
case "DELETE":
try {
text.RemoveRange(int.Parse(parts[1]), int.Parse(parts[2]));
Console.WriteLine("OK");
}
catch(Exception) {
Console.WriteLine("ERROR");
}
break;
}
} while("PRINT" != command);
Console.WriteLine (text);
}
private static void Add(char[] stringToAdd, BigList <char> stringContainer)
{
foreach (var character in stringToAdd)
{
stringContainer.Add(character);
}
}
private static void HandleAddCommand(string[] command)
{
string name = command[1];
string type = command[2];
int age = int.Parse(command[3]);
int position = int.Parse(command[4]) - 1;
Player player = new Player(name, type, age, position);
bool typeIsFound = playersSortedByType.ContainsKey(type);
if (!typeIsFound)
{
playersSortedByType.Add(type, new SortedSet <Player>());
}
if (playersSortedByType[type].Contains(player))
{
return;
}
playersSortedByType[type].Add(player);
if (position > players.Count)
{
players.Add(player);
}
else
{
players.Insert(position, player);
}
Console.WriteLine("Added player {0} to position {1}", player.Name, player.Position + 1);
}
public virtual VirtualTable GroupMax(ObjectName maxColumn)
{
BigList <long> rowList;
if (table.RowCount <= 0)
{
rowList = new BigList <long>(0);
}
else
{
// OPTIMIZATION: This should be optimized. It should be fairly trivial
// to generate a Table implementation that efficiently merges this
// function table with the reference table.
// This means there is no grouping, so merge with entire table,
var rowCount = table.RowCount;
rowList = new BigList <long>(rowCount);
using (var en = table.GetEnumerator()) {
while (en.MoveNext())
{
rowList.Add(en.Current.Number);
}
}
}
// Create a virtual table that's the new group table merged with the
// functions in this...
var tabs = new[] { table, this };
var rowSets = new IEnumerable <long>[] { rowList, rowList };
return(new VirtualTable(tabs, rowSets));
}
static void Main(string[] args)
{
var sequence = Enumerable.Range(1, 12);
BigList <int> numbersList = new BigList <int>(sequence);
BigList <int> temp = new BigList <int>();
int[] swapNumbers = new int[] { 11, 5, 10, 6, 9, 10 };
int i = 0; //TODO - REMOVE
int swap = swapNumbers[i];
//int swap = 15;
Console.WriteLine($"Swap number = {swap}");
var found = numbersList.IndexOf(swap);
Console.WriteLine("Original sequence:");
Console.WriteLine(string.Join(" ", numbersList));
//cut items before and after swap number
for (int j = 0; j < numbersList.IndexOf(swap); j++)
{
temp.Add(numbersList[j]);
}
while (numbersList[0] != swap + 1)
{
numbersList.RemoveAt(0);
}
Console.WriteLine("Numbers before and after swap number:");
Console.WriteLine(string.Join(" ", temp));
Console.WriteLine(string.Join(" ", numbersList));
//add numbers after swap
numbersList.Add(swap);
foreach (var number in temp)
{
numbersList.Add(number);
}
temp.RemoveRange(0, temp.Count);
Console.WriteLine("New sequence:");
Console.WriteLine(string.Join(" ", numbersList));
//Console.WriteLine($"Number of items in temporary list: {temp.Count}");
Console.WriteLine("END OF ROUND\n\n");
}
static string Append(string name)
{
names.Add(name);
data.Add(name);
return("OK");
}
/// <summary>
/// Creates a new edge in the GSS
/// </summary>
/// <param name="from">The edge's starting node</param>
/// <param name="to">The edge's target node</param>
/// <param name="label">The edge's label</param>
public void CreateEdge(int from, int to, int label)
{
edges.Add(new GSSEdge(from, to, label));
GSSGeneration data = edgeGenerations[generation];
data.Count++;
edgeGenerations[generation] = data;
}
private static void Insert(string[] command)
{
int position = int.Parse(command[1]);
string name = command[2];
if (position == 0)
{
list.AddToFront(name);
if (!bla.ContainsKey(name))
{
bla.Add(name, 0);
}
bla[name]++;
sb.AppendLine("OK");
}
else if (position == list.Count)
{
list.Add(name);
if (!bla.ContainsKey(name))
{
bla.Add(name, 0);
}
bla[name]++;
sb.AppendLine("OK");
}
else if (position > list.Count)
{
sb.AppendLine("Error");
}
else
{
list.Insert(position, name);
sb.AppendLine("OK");
if (!bla.ContainsKey(name))
{
bla.Add(name, 0);
}
bla[name]++;
}
}
private static void Append(BigList<char> text, string textToAppend, bool shouldPrint = true)
{
for (int i = 0; i < textToAppend.Length; i++)
{
text.Add(textToAppend[i]);
}
PrintSuccessMessage(shouldPrint);
}
public static void ContainsItem()
{
var index = new SortedCollection <SqlObject, long>();
var items = new BigList <SqlObject>();
items.Add(SqlObject.Integer(435));
items.Add(SqlObject.Integer(1920));
items.Add(SqlObject.Integer(9182));
var comparer = new CollectionComparer(items);
index.InsertSort(items[0], 0, comparer);
index.InsertSort(items[1], 1, comparer);
index.InsertSort(items[2], 2, comparer);
Assert.True(index.Contains(SqlObject.Integer(435), comparer));
Assert.False(index.Contains(SqlObject.Integer(21), comparer));
}
/// <summary>
/// Creates a new node in the GSS
/// </summary>
/// <param name="state">The GLR state represented by the node</param>
/// <returns>The node's identifier</returns>
public int CreateNode(int state)
{
int node = nodeLabels.Add(state);
GSSGeneration data = nodeGenerations[generation];
data.Count++;
nodeGenerations[generation] = data;
return(node);
}
public static Pair <Genotype, Genotype> Splice(Genotype genome1, Genotype genome2, int splicePoint1, int splicePoint2)
{
// TODO Here we use an inefficient version which creates two containers of genes
// to replace the originals. Ideally, this would be done as it was in the
// C++ version with std::list splicing - or by implementing this class in C++/CLR
Debug.Assert(genome1.Count >= 2);
Debug.Assert(genome2.Count >= 2);
Debug.Assert(splicePoint1 < genome1.Count);
Debug.Assert(splicePoint2 < genome2.Count);
BigList <Gene> newGenes1 = new BigList <Gene>();
BigList <Gene> newGenes2 = new BigList <Gene>();
IEnumerator <Gene> p = genome1.genes.GetEnumerator();
for (int i = 0; i < splicePoint1; ++i)
{
p.MoveNext();
newGenes1.Add((Gene)p.Current.Clone());
}
IEnumerator <Gene> q = genome2.genes.GetEnumerator();
for (int j = 0; j < splicePoint2; ++j)
{
q.MoveNext();
newGenes2.Add((Gene)q.Current.Clone());
}
for (int i = splicePoint1; i < genome1.genes.Count; ++i)
{
p.MoveNext();
newGenes2.Add((Gene)p.Current.Clone());
}
for (int j = splicePoint2; j < genome2.genes.Count; ++j)
{
q.MoveNext();
newGenes1.Add((Gene)q.Current.Clone());
}
Debug.Assert(newGenes1.Count + newGenes2.Count == genome1.Count + genome2.Count);
return(new Pair <Genotype, Genotype>(new Genotype(newGenes1), new Genotype(newGenes2)));
}
private static string Append(IList <string> commandArgs)
{
var personName = commandArgs[0];
supermarketQueue.Add(personName);
UpdatePersonCount(personName);
return("OK");
}
public static void CreateFromOtherIndex()
{
var index = new SortedCollection <SqlObject, long>();
var items = new BigList <SqlObject>();
items.Add(SqlObject.Integer(435));
items.Add(SqlObject.Integer(1920));
items.Add(SqlObject.Integer(9182));
var comparer = new CollectionComparer(items);
index.InsertSort(items[0], 0, comparer);
index.InsertSort(items[1], 1, comparer);
index.InsertSort(items[2], 2, comparer);
var index2 = new SortedCollection <SqlObject, long>(index);
Assert.Equal(index.Count, index2.Count);
}
static void Main(string[] args)
{
BigList <string> totalJedi = new BigList <string>();
Queue <string> knights = new Queue <string>();
List <string> padawans = new List <string>();
int n = int.Parse(Console.ReadLine());
string[] jedis = Console.ReadLine().Split();
for (int i = 0; i < n; i++)
{
string temp = jedis[i];
switch (temp[0])
{
case 'M':
totalJedi.Add(jedis[i]);
break;
case 'K':
knights.Enqueue(jedis[i]);
break;
case 'P':
padawans.Add(jedis[i]);
break;
default:
break;
}
}
while (knights.Count != 0)
{
totalJedi.Add(knights.Dequeue());
}
foreach (var padawan in padawans)
{
totalJedi.Add(padawan);
}
Console.WriteLine(string.Join(" ", totalJedi));
}
private static void AppendPerson(string name)
{
queueOfPositions.Add(name);
if (!queueOfNames.ContainsKey(name))
{
queueOfNames.Add(name, 0);
}
queueOfNames[name]++;
uniqueClientId++;
result.AppendLine("OK");
}
private BigList <long> CalculateTableRows()
{
var size = RowCount;
var allList = new BigList <long>(size);
for (int i = 0; i < size; ++i)
{
allList.Add(i);
}
return(allList);
}
private static void AppendCommand(Command command, StringBuilder output)
{
name.Add(command.Param);
if (!findNames.ContainsKey(command.Param))
{
findNames.Add(command.Param, 0);
}
findNames[command.Param]++;
output.AppendLine("OK");
}
protected override RawTableInfo GetRawTableInfo(RawTableInfo rootInfo)
{
var size = RowCount;
var allList = new BigList <long>(size);
for (long i = 0; i < size; ++i)
{
allList.Add(i);
}
return(GetRawTableInfo(rootInfo, allList));
}
static void AddPlayer(Player p, BigList<Player> ranking)
{
if (ranking.Count >= p.Position)
{
ranking.Insert(p.Position - 1, p);
}
else
{
ranking.Add(p);
}
Console.WriteLine("Added player {0} to position {1}", p.Name, p.Position);
}
public static void SearcLast_Sort()
{
var index = new SortedCollection <SqlObject, long>();
var items = new BigList <SqlObject>();
items.Add(SqlObject.Integer(435));
items.Add(SqlObject.Integer(1920));
items.Add(SqlObject.Integer(9182));
var comparer = new CollectionComparer(items);
index.InsertSort(items[0], 0, comparer);
index.InsertSort(items[1], 1, comparer);
index.InsertSort(items[2], 2, comparer);
Assert.Equal(3, index.Count);
var first = index.SearchLast(SqlObject.Integer(435), comparer);
Assert.Equal(0, first);
}
private void DoInsertSort(BigList <long> list, long row)
{
var listSize = list.Count;
if (listSize == 0)
{
list.Add(row);
}
else
{
var point = HighestSearch(GetKey(row), list, 0, listSize - 1);
if (point == listSize)
{
list.Add(row);
}
else
{
list.Insert(point, row);
}
}
}
public static void AddAndRemoveItem()
{
var index = new SortedCollection <SqlObject, long>();
var items = new BigList <SqlObject>();
items.Add(SqlObject.Integer(435));
items.Add(SqlObject.Integer(1920));
items.Add(SqlObject.Integer(9182));
var comparer = new CollectionComparer(items);
index.InsertSort(items[0], 0, comparer);
index.InsertSort(items[1], 1, comparer);
index.InsertSort(items[2], 2, comparer);
Assert.Equal(3, index.Count);
var value = index.RemoveSort(SqlObject.Integer(435), 0, comparer);
Assert.Equal(0, value);
}
private IEnumerable <long> GetTopRowsFromEachGroup()
{
var extractRows = new BigList <long>();
var size = groupLinks.Count;
for (int i = 0; i < size; ++i)
{
var r = groupLinks[i];
extractRows.Add(r[0]);
}
return(extractRows);
}
public JsonResult Insert()
{
OrderedDictionary<int, BigList<double>> orderedDic = new OrderedDictionary<int, BigList<double>>();
BigList<double> bigList = new BigList<double>();
Parallel.For(1, 10000, x =>
{
lock(this)
{
bigList.Add(x * Math.PI * new Random().NextDouble());
}
});
orderedDic.Add(Environment.CurrentManagedThreadId, bigList);
tree.Insert(orderedDic, DuplicatePolicy.InsertFirst, out orderedDic);
return Json(new { OrderedDictionary = orderedDic }, JsonRequestBehavior.AllowGet);
}
public GameScreen()
{
closedList = new BigList<GameObject>();
shells = new BigList<Shell>();
player = new Player();
earth = new Earth();
glow = new Glow();
//map = new Map();
mCollisions = new MasterCollisions();
closedList.Add(glow);
closedList.Add(player);
closedList.Add(earth);
for (int i = 0; i < 100; i++)
{
shells.Add(new Shell());
closedList.Add(shells.Last());
}
}
/// <summary>
/// BigList<T> (WITH DUPLICATES)
/// Editable sequence of indexed items
/// Like List<T> but provides
/// Fast Insert / Delete operations (at any position)
/// Fast Copy / Concat / Sub-range operations
/// Implemented by the data structure "Rope"
/// Special kind of balanced binary tree: http://en.wikipedia.org/wiki/Rope_(data_structure)
/// </summary>
private static void TestBigList()
{
BigList<Student> students = new BigList<Student>();
var student1 = new Student("First DUPLICATE", 21);
var student2 = new Student("Second", 21);
var student3 = new Student("Third", 22);
var student4 = new Student("Forth", 23);
var student5 = new Student("Fifth", 24);
Console.WriteLine();
students.Add(student1);
students.Add(student2);
students.Add(student3);
students.Add(student4);
students.Add(student5);
students.Add(student1);
Console.WriteLine("===== BEFORE SORT =====");
Console.WriteLine("Index of student1: " + students.BinarySearch(student1));
Console.WriteLine("Index of student2: " + students.BinarySearch(student2));
Console.WriteLine("Index of student3: " + students.BinarySearch(student3));
Console.WriteLine("Index of student4: " + students.BinarySearch(student4));
Console.WriteLine("Index of student5: " + students.BinarySearch(student5));
foreach (var item in students)
{
Console.WriteLine(item);
}
students.Sort();
Console.WriteLine("===== AFTER SORT =====");
Console.WriteLine("Index of student1: " + students.BinarySearch(student1));
Console.WriteLine("Index of student2: " + students.BinarySearch(student2));
Console.WriteLine("Index of student3: " + students.BinarySearch(student3));
Console.WriteLine("Index of student4: " + students.BinarySearch(student4));
Console.WriteLine("Index of student5: " + students.BinarySearch(student5));
foreach (var item in students)
{
Console.WriteLine(item);
}
Console.WriteLine("===== INDEX students[3] =====");
Console.WriteLine(students[3]);
}
public static void FillLabourNormList(TrudoyomkostDBContext dbcontext, ref BigList<LabourNorm> inputList)
{
var tempresult = from labourlist in dbcontext.LabourNorm
select labourlist;
inputList.Clear();
//IList temp = tempresult.ToList();
foreach (var item in tempresult)
{
inputList.Add(item);
}
}
public static void FillWhereOperationUseList(TrudoyomkostDBContext dbcontext, ref BigList<WhereOperationUse> inputList)
{
var tempresult = from labourlist in dbcontext.WhereOperationUse
select labourlist;
inputList.Clear();
foreach (var item in tempresult)
{
inputList.Add(item);
}
}
static void Main()
{
Console.Write("Bag of Integers: ");
var bagOfInts = new Bag<int>();
bagOfInts.Add(3);
bagOfInts.Add(5);
bagOfInts.Add(5);
bagOfInts.Add(5);
bagOfInts.Add(10);
bagOfInts.Add(20);
bagOfInts.Add(20);
bagOfInts.Remove(5);
bagOfInts.RemoveAllCopies(20);
bagOfInts.UnionWith(new Bag<int>() { 3, 3, 4, 4, 5, 5 });
Console.WriteLine(bagOfInts);
Console.Write("OrderedBag of Integers: ");
var orderedBagOfInts = new OrderedBag<int>();
orderedBagOfInts.Add(3);
orderedBagOfInts.Add(5);
orderedBagOfInts.Add(5);
orderedBagOfInts.Add(5);
orderedBagOfInts.Add(10);
orderedBagOfInts.Add(20);
orderedBagOfInts.Add(20);
orderedBagOfInts.Remove(5);
orderedBagOfInts.RemoveAllCopies(20);
orderedBagOfInts.UnionWith(new OrderedBag<int>() { 3, 3, 4, 4, 5, 5 });
Console.WriteLine(orderedBagOfInts);
Console.WriteLine("Sub-range [5...10]: " +
orderedBagOfInts.Range(5, true, 10, true));
Console.Write("Set of Integers: ");
var setOfInts = new Set<int>();
setOfInts.Add(3);
setOfInts.Add(5);
setOfInts.Add(5);
setOfInts.Add(5);
setOfInts.Add(10);
setOfInts.Add(20);
setOfInts.Add(20);
setOfInts.Remove(5);
setOfInts.UnionWith(new Set<int>() { 3, 4, 5 });
Console.WriteLine(setOfInts);
Console.Write("OrderedSet of Integers: ");
var orderedSetOfInts = new OrderedSet<int>();
orderedSetOfInts.Add(3);
orderedSetOfInts.Add(5);
orderedSetOfInts.Add(5);
orderedSetOfInts.Add(5);
orderedSetOfInts.Add(10);
orderedSetOfInts.Add(20);
orderedSetOfInts.Add(20);
orderedSetOfInts.Remove(5);
orderedSetOfInts.UnionWith(new OrderedSet<int>() { 3, 4, 5 });
Console.WriteLine(orderedSetOfInts);
Console.WriteLine("Sub-range [5...20): " +
orderedSetOfInts.Range(5, true, 20, false));
Console.Write("MultiDictionary<string,int>: ");
var studentGrades = new MultiDictionary<string, int>(true);
studentGrades.Add("Peter", 3);
studentGrades.Add("Peter", 4);
studentGrades.Add("Peter", 4);
studentGrades.Add("Stanka", 6);
studentGrades.Add("Stanka", 5);
studentGrades.Add("Stanka", 6);
studentGrades.Add("Tanya", 6);
studentGrades.Add("Tanya", 4);
Console.WriteLine(studentGrades);
Console.WriteLine("OrderedMultiDictionary<string,int>:");
var distancesFromSofia = new OrderedMultiDictionary<int, string>(true);
distancesFromSofia.Add(149, "Plovdiv");
distancesFromSofia.Add(505, "Varna");
distancesFromSofia.Add(394, "Bourgas");
distancesFromSofia.Add(310, "Rousse");
distancesFromSofia.Add(163, "Pleven");
distancesFromSofia.Add(163, "Troyan");
foreach (var distanceTowns in distancesFromSofia)
{
Console.WriteLine("\t" + distanceTowns);
}
Console.Write("Deque<string>: ");
var people = new Deque<string>();
people.AddToBack("Kiro");
people.AddToBack("Maria");
people.AddToFront("Steve");
people.AddManyToBack(new string[] { "Ivan", "Veronika" });
Console.WriteLine(people);
Console.Write("BigList<int>: ");
var ints = new BigList<int>();
// var ints = new List<int>();
for (int i = 0; i < 1000000; i++)
{
ints.Add(i);
}
for (int i = 0; i < 50000; i++)
{
ints.Insert(i, i);
}
Console.WriteLine(ints.Count);
}
public static void Main()
{
BigList<string> names = new BigList<string>();
Dictionary<string,int> namesCounter= new Dictionary<string, int>();
string[] input = Console.ReadLine().Split(' ');
StringBuilder result = new StringBuilder();
while (input[0] != "End")
{
switch (input[0])
{
case "Append":
{
names.Add(input[1]);
if (!namesCounter.ContainsKey(input[1]))
{
namesCounter.Add(input[1], 1);
}
else
{
namesCounter[input[1]]++;
}
result.AppendLine("OK");
break;
}
case "Insert":
{
var position = int.Parse(input[1]);
try
{
names.Insert(position, input[2]);
result.AppendLine("OK");
}
catch (ArgumentOutOfRangeException ex)
{
result.AppendLine("Error");
break;
}
if (!namesCounter.ContainsKey(input[2]))
{
namesCounter.Add(input[2], 1);
}
else
{
namesCounter[input[2]]++;
}
break;
}
case "Find":
{
string name = input[1];
if (namesCounter.ContainsKey(input[1]))
{
result.AppendLine(namesCounter[input[1]].ToString());
}
else
{
result.AppendLine("0");
}
break;
}
case "Serve":
{
int count = int.Parse(input[1]);
if (count > names.Count)
{
result.AppendLine("Error");
break;
}
var l = names.Range(0, count);
StringBuilder k = new StringBuilder();
for(var p=0;p<l.Count;p++)
{
var o = l[p];
k.Append(o).Append(' ');
namesCounter[o]--;
}
result.AppendLine(k.ToString().Trim(' '));
names.RemoveRange(0,count);
break;;
}
}
input = Console.ReadLine().Split(' ');
}
Console.WriteLine(result);
}
static void Main()
{
var rope = new BigList<char>();
string input = "";
while (input != "END")
{
input = Console.ReadLine();
var inputTokens = input.Trim().Split(' ');
var command = inputTokens[0];
if (command == "APPEND")
{
var textToAppend = input.Substring(7);
for (int i = 0; i < textToAppend.Length; i++)
{
rope.Add(textToAppend[i]);
}
Console.WriteLine("OK");
}
if (command == "INSERT")
{
int positionToInsert = int.Parse(inputTokens[1]);
if (IsValidIndex(positionToInsert, rope))
{
var textToInsert = inputTokens[2];
rope.InsertRange(positionToInsert, textToInsert);
Console.WriteLine("OK");
}
else
{
Console.WriteLine("ERROR");
}
}
if (command == "DELETE")
{
int deleteFrom = int.Parse(inputTokens[1]);
int deleteCount = int.Parse(inputTokens[2]);
if ((IsValidIndex(deleteFrom, rope) && IsValidIndex(deleteCount, rope)) && ((deleteFrom + deleteCount) <= rope.Count))
{
rope.RemoveRange(deleteFrom, deleteCount);
Console.WriteLine("OK");
}
else
{
Console.WriteLine("ERROR");
}
}
if (command == "REPLACE")
{
int replaceFrom = int.Parse(inputTokens[1]);
int replaceCount = int.Parse(inputTokens[2]);
if ((IsValidIndex(replaceFrom, rope) && IsValidIndex(replaceCount, rope)) && ((replaceFrom + replaceCount) <= rope.Count))
{
var replaceText = new List<string>();
for (int i = 3; i < inputTokens.Length; i++)
{
replaceText.Add(inputTokens[i]);
}
rope.RemoveRange(replaceFrom, replaceCount);
rope.InsertRange(replaceFrom, string.Join(" ", replaceText));
Console.WriteLine("OK");
}
else
{
Console.WriteLine("ERROR");
}
}
if (command == "PRINT")
{
Console.WriteLine(string.Join("", rope));
}
}
}
private static void Main(string[] args)
{
var queue = new BigList<string>();
var names = new Dictionary<string, int>();
var commandParts = Console.ReadLine().Split(' ');
var result = new StringBuilder();
while (commandParts[0] != "End")
{
switch (commandParts[0])
{
case "Append":
queue.Add(commandParts[1]);
if (!names.ContainsKey(commandParts[1]))
{
names[commandParts[1]] = 0;
}
names[commandParts[1]]++;
result.AppendLine("OK");
break;
case "Insert":
var index = int.Parse(commandParts[1]);
if (index > queue.Count)
{
result.AppendLine("Error");
break;
}
result.AppendLine("OK");
if (!names.ContainsKey(commandParts[2]))
{
names[commandParts[2]] = 0;
}
names[commandParts[2]]++;
if (index == queue.Count)
{
queue.Add(commandParts[2]);
break;
}
queue.Insert(index, commandParts[2]);
break;
case "Find":
if (!names.ContainsKey(commandParts[1]))
{
result.AppendLine("0"); break;
}
result.AppendLine(names[commandParts[1]].ToString());
break;
case "Serve":
var count = int.Parse(commandParts[1]);
if (count > queue.Count)
{
result.AppendLine("Error");
break;
}
var served = new StringBuilder();
for (int i = 0; i < count; i++)
{
var person = queue[0];
names[person]--;
served.AppendFormat(" {0}", person);
queue.RemoveAt(0);
}
result.AppendLine(served.ToString().Trim());
break;
}
commandParts = Console.ReadLine().Split(' ');
}
Console.WriteLine(result.ToString());
}