private static void SwapExample()
{
var a = 10;
var b = 20;
Swapper.Swap(ref a, ref b);
// V premennych by mali byt tieto hodnoty:
// a = 20, b = 10
Console.WriteLine($"{a} {b}");
var d1 = Math.PI;
var d2 = Math.E;
Swapper.Swap(ref d1, ref d2);
// V premennych by mali byt tieto hodnoty:
// d1 = Math.E, d2 = Math.PI
Console.WriteLine($"{d1} {d2}");
var hello = "Ahoj";
var world = "svet";
Swapper.Swap(ref hello, ref world);
// V premennych by mali byt tieto hodnoty:
// hello = "svet", world = "Ahoj"
Console.WriteLine($"{hello} {world}");
// Pozadovany vystup:
// 20 10
// 2,718281828459045 3,141592653589793
// svet Ahoj
}
public static bool ContainsAny(FlagSet a, FlagSet b)
{
if (a == null || a.IsEmpty || b == null || b.IsEmpty)
{
return(false);
}
if (a.Count == 1)
{
return(b.Contains(a[0]));
}
if (b.Count == 1)
{
return(a.Contains(b[0]));
}
if (a.Count > b.Count)
{
Swapper.Swap(ref a, ref b);
}
foreach (var item in a)
{
if (b.Contains(item))
{
return(true);
}
}
return(false);
}
public SortingResult Sort(Data[] array)
{
SortingResult sortingResult = new SortingResult {
ArrayOfData = array
};
var watch = Stopwatch.StartNew();
for (int i = 1; i < array.Length; i++)
{
bool continueComparing = true;
for (int g = i; g > 0 && continueComparing; g--)
{
continueComparing = (_compareMethod(array[g - 1], array[g]) == 1);
sortingResult.CountOfCompares++;
if (continueComparing)
{
Swapper.Swap(ref array[g], ref array[g - 1]);
sortingResult.CountOfSwaps++;
}
}
}
watch.Stop();
sortingResult.Time = watch.Elapsed;
return(sortingResult);
}
public SortingResult Sort(Data[] array)
{
SortingResult sortingResult = new SortingResult {
ArrayOfData = array
};
var watch = Stopwatch.StartNew();
bool isOrdered = false;
for (int i = 0; i < array.Length && !isOrdered; i++)
{
for (int g = 0; g < (array.Length - 1); g++)
{
sortingResult.CountOfCompares++;
if (_compareMethod(array[g], array[g + 1]) == 1)
{
Swapper.Swap(ref array[g], ref array[g + 1]);
sortingResult.CountOfSwaps++;
}
}
isOrdered = CheckState(array, sortingResult);
}
watch.Stop();
sortingResult.Time = watch.Elapsed;
return(sortingResult);
}
public SortingResult Sort(Data[] array)
{
SortingResult sortingResult = new SortingResult {
ArrayOfData = array
};
var watch = Stopwatch.StartNew();
for (int i = 0; i < array.Length; i++)
{
for (int g = 0; g < (array.Length - 1); g++)
{
sortingResult.CountOfCompares++;
if (_compareMethod.Invoke(array[g], array[g + 1]) == 1)
{
Swapper.Swap(ref array[g], ref array[g + 1]);
sortingResult.CountOfSwaps++;
}
}
}
watch.Stop();
sortingResult.Time = watch.Elapsed;
return(sortingResult);
}
private (double tMin, double tMax) CheckAxis(double origin, double direction, double min, double max)
{
var tMinNumerator = min - origin;
var tMaxNumerator = max - origin;
double tMin, tMax;
if (Math.Abs(direction) >= C.Epsilon)
{
tMin = tMinNumerator / direction;
tMax = tMaxNumerator / direction;
}
else
{
tMin = tMinNumerator * double.PositiveInfinity;
tMax = tMaxNumerator * double.PositiveInfinity;
}
if (tMin > tMax)
{
Swapper.Swap(ref tMin, ref tMax);
}
return(tMin, tMax);
}
private IEnumerable <Intersection> IntersectWalls(Ray localRay)
{
var a = Math.Pow(localRay.Direction.x, 2) - Math.Pow(localRay.Direction.y, 2) + Math.Pow(localRay.Direction.z, 2);
var b =
2 * localRay.Origin.x * localRay.Direction.x -
2 * localRay.Origin.y * localRay.Direction.y +
2 * localRay.Origin.z * localRay.Direction.z;
var c =
Math.Pow(localRay.Origin.x, 2) -
Math.Pow(localRay.Origin.y, 2) +
Math.Pow(localRay.Origin.z, 2);
if (Math.Abs(a) < C.Epsilon)
{
// Ray is parallell to one of the cones halves
if (Math.Abs(b) < C.Epsilon)
{
yield break;
}
var t = -c / (2 * b);
var y = localRay.Origin.y + t * localRay.Direction.y;
if (Min < y && y < Max)
{
yield return(new Intersection(t, this));
}
yield break;
}
var disc = Math.Pow(b, 2) - 4 * a * c;
if (disc < 0)
{
// Ray does not intersect the cone
yield break;
}
var t0 = (-b - Math.Sqrt(disc)) / (2 * a);
var t1 = (-b + Math.Sqrt(disc)) / (2 * a);
if (t0 > t1)
{
Swapper.Swap(ref t0, ref t1);
}
var y0 = localRay.Origin.y + t0 * localRay.Direction.y;
if (Min < y0 && y0 < Max)
{
yield return(new Intersection(t0, this));
}
var y1 = localRay.Origin.y + t1 * localRay.Direction.y;
if (Min < y1 && y1 < Max)
{
yield return(new Intersection(t1, this));
}
}
internal int Pivot(IList array, int lower, int upper)
{
// Pivot with first element
var left = lower + 1;
var pivot = array[lower];
var right = upper;
// Partition array elements
while (left <= right)
{
// Find item out of place
while ((left <= right) && (Comparer.Compare(array[left], pivot) <= 0))
{
++left;
}
while ((left <= right) && (Comparer.Compare(array[right], pivot) > 0))
{
--right;
}
// Swap values if necessary
if (left < right)
{
Swapper.Swap(array, left, right);
++left;
--right;
}
}
// Move pivot element
Swapper.Swap(array, lower, right);
return(right);
}
private void DownHeap(IList list, int k, int n)
{
var loop = true;
while (k <= n / 2 && loop)
{
var j = k + k;
if (j < n)
{
if (Comparer.Compare(list[j - 1], list[j]) < 0)
{
j++;
}
}
if (Comparer.Compare(list[k - 1], list[j - 1]) >= 0)
{
loop = false;
}
else
{
Swapper.Swap(list, k - 1, j - 1);
k = j;
}
}
}
public override void Sort(IList list)
{
var i = 0;
var k = list.Count - 1;
while (i < k)
{
var min = i;
var max = i;
int j;
for (j = i + 1; j <= k; j++)
{
if (Comparer.Compare(list[j], list[min]) < 0)
{
min = j;
}
if (Comparer.Compare(list[j], list[max]) > 0)
{
max = j;
}
}
Swapper.Swap(list, min, i);
Swapper.Swap(list, max == i ? min : max, k);
i++;
k--;
}
}
protected void dgTroca_ItemCommand(object sender, DataGridCommandEventArgs e)
{
if (e.CommandName == "Aceitou")
{
List <Troca> trocas = (List <Troca>)Session["Trocas"];
try
{
Troca troca = trocas[e.Item.ItemIndex];
troca.EstaPendente = false;
troca.FoiAceita = true;
troca.FoiVisualizada = true;
Aula aulaAtual = troca.AlocacaoAtual.Aula;
Aula aulaDesejada = troca.AlocacaoDesejada.Aula;
Evento eventoAtual = troca.AlocacaoAtual.Evento;
Evento eventoDesejado = troca.AlocacaoDesejada.Evento;
Swapper.Swap <Aula>(ref aulaAtual, ref aulaDesejada);
Swapper.Swap <Evento>(ref eventoAtual, ref eventoDesejado);
trocaBO.UpDateTroca(troca);
troca.AlocacaoAtual.Aula = aulaAtual;
troca.AlocacaoDesejada.Aula = aulaDesejada;
troca.AlocacaoAtual.Evento = eventoAtual;
troca.AlocacaoDesejada.Evento = eventoDesejado;
alocBO.UpdateAlocacao(troca.AlocacaoAtual);
alocBO.UpdateAlocacao(troca.AlocacaoDesejada);
VerificaTrocas();
}
catch (Exception)
{
Response.Redirect("~/Default/Erro.aspx?Erro=Erro ao aceitar a troca.");
}
}
if (e.CommandName == "Recusou")
{
List <Troca> trocas = (List <Troca>)Session["Trocas"];
try
{
Troca troca = trocas[e.Item.ItemIndex];
troca.EstaPendente = false;
troca.FoiAceita = false;
troca.FoiVisualizada = true;
trocaBO.UpDateTroca(troca);
VerificaTrocas();
}
catch (Exception)
{
Response.Redirect("~/Default/Erro.aspx?Erro=Erro ao recusar a troca.");
}
}
}
public void Swap_WithValidArray_IsSuccessful()
{
var a = new [] { 1, 2 };
Swapper <int> .Swap(a, 0, 1);
Assert.Equal(2, a[0]);
Assert.Equal(1, a[1]);
}
static void NodeTest()
{
Console.WriteLine("I'm testing node");
string done = "";
Node <int> linkedList = new Node <int>(0);
Node <int> root = linkedList;
while (done != "y")
{
Console.WriteLine("Insert an integer for Linked List");
int value = Convert.ToInt32(Console.ReadLine());
linkedList.next = new Node <int>(value);
linkedList = linkedList.next;
Console.WriteLine("Are you done adding y/n?");
done = Console.ReadLine().ToLower();
}
Node <int> List = new Node <int>(8);
List.next = new Node <int>(4, List.root);
List++;
List.next = new Node <int>(1, List.root);
List++;
List.next = new Node <int>(2, List.root);
List++;
List.next = new Node <int>(3, List.root);
List++;
List.next = new Node <int>(7, List.root);
List++;
List = List.root;
List.Print();
List.next.Print();
Swapper <int> .Swap(List.next, List.next.next);
Console.WriteLine("THis is swaped virsooooon");
List.Print();
//Console.WriteLine("...");
List.next.Print();
/*
* Node<double> n0 = new Node<double>(0.0);
* n0.next = new Node<double>(1.0);
* Node<double> www = n0[0];
* n0[0].Print();
* if(n0 == n1)
* {
* Console.WriteLine("they are equal");
* }
* else
* {
* Console.WriteLine("they are NOT equal");
* }
*/
// linkedList.Print();
// linkedList.PrintAll();
}
public void SwapperSwapsStringBoxesInList()
{
List <Box <string> > numbers = new List <Box <string> >();
numbers.Add(new Box <string>("Pesho"));
numbers.Add(new Box <string>("Ivan"));
Swapper.Swap(numbers, 0, 1);
Assert.IsTrue(numbers[0].Item == "Ivan" && numbers[1].Item == "Pesho");
}
/// <summary>
/// This is a generic version of C.A.R Hoare's Quick Sort
/// algorithm. This will handle arrays that are already
/// sorted, and arrays with duplicate keys.
/// </summary>
/// <remarks>
/// If you think of a one dimensional array as going from
/// the lowest index on the left to the highest index on the right
/// then the parameters to this function are lowest index or
/// left and highest index or right. The first time you call
/// this function it will be with the parameters 0, a.length - 1.
/// </remarks>
/// <param name="list">list to sort</param>
/// <param name="l">left boundary of array partition</param>
/// <param name="r">right boundary of array partition</param>
internal void QuickSort(IList list, int l, int r)
{
const int m = 4;
if (r - l <= m)
{
return;
}
var i = (r + l) / 2;
if (Comparer.Compare(list[l], list[i]) > 0)
{
Swapper.Swap(list, l, i); // Tri-Median Methode!
}
if (Comparer.Compare(list[l], list[r]) > 0)
{
Swapper.Swap(list, l, r);
}
if (Comparer.Compare(list[i], list[r]) > 0)
{
Swapper.Swap(list, i, r);
}
var j = r - 1;
Swapper.Swap(list, i, j);
i = l;
var v = list[j];
for (;;)
{
while (Comparer.Compare(list[++i], v) > 0)
{
}
while (Comparer.Compare(list[--j], v) < 0)
{
}
if (j < i)
{
break;
}
Swapper.Swap(list, i, j);
}
Swapper.Swap(list, i, r - 1);
QuickSort(list, l, j);
QuickSort(list, i + 1, r);
}
public void SwapperSwapsBoxesInList()
{
List <Box <int> > numbers = new List <Box <int> >();
numbers.Add(new Box <int>(2));
numbers.Add(new Box <int>(5));
Swapper.Swap(numbers, 0, 1);
Assert.IsTrue(numbers[0].Item == 5 && numbers[1].Item == 2);
}
public override void Sort(IList list)
{
for (var i = list.Count; --i >= 0;)
{
for (var j = 0; j < i; j++)
{
if (Comparer.Compare(list[j], list[j + 1]) > 0)
{
Swapper.Swap(list, j, j + 1);
}
}
}
}
internal void SortPart1(IList list, int Lo, int Hi, int Nx, bool Up)
{
int c;
for (int j = Lo; j + Nx < Hi; j += 2 * Nx)
{
c = Comparer.Compare(list[j], list[j + Nx]);
if ((Up && c > 0) || !Up && c < 0)
{
Swapper.Swap(list, j, j + Nx);
}
}
}
private IEnumerable <Intersection> IntersectWalls(Ray localRay)
{
var a = Math.Pow(localRay.Direction.x, 2) + Math.Pow(localRay.Direction.z, 2);
if (a < C.Epsilon)
{
// Ray is parallell to the y axis
yield break;
}
var b =
2 * localRay.Origin.x * localRay.Direction.x +
2 * localRay.Origin.z * localRay.Direction.z;
var c =
Math.Pow(localRay.Origin.x, 2) +
Math.Pow(localRay.Origin.z, 2) -
1;
var disc = Math.Pow(b, 2) - 4 * a * c;
if (disc < 0)
{
// Ray does not intersect the cylinder
yield break;
}
var t0 = (-b - Math.Sqrt(disc)) / (2 * a);
var t1 = (-b + Math.Sqrt(disc)) / (2 * a);
if (t0 > t1)
{
Swapper.Swap(ref t0, ref t1);
}
var y0 = localRay.Origin.y + t0 * localRay.Direction.y;
if (Min < y0 && y0 < Max)
{
yield return(new Intersection(t0, this));
}
var y1 = localRay.Origin.y + t1 * localRay.Direction.y;
if (Min < y1 && y1 < Max)
{
yield return(new Intersection(t1, this));
}
}
public void Possess()
{
if (Input.GetKeyDown(KeyCode.Space))
{
foreach (Collider obj in Physics.OverlapSphere(transform.position, 3))
{
Swapper swap = obj.GetComponent <Swapper>();
if (swap != null && swap.transform != GetComponent <Swapper>().transform)
{
swap.Swap();
GetComponent <Swapper>().Swap();
}
}
}
}
/// <summary>
/// This is a generic version of C.A.R Hoare's Quick Sort
/// algorithm. This will handle arrays that are already
/// sorted, and arrays with duplicate keys.
/// </summary>
/// <remarks>
/// If you think of a one dimensional array as going from
/// the lowest index on the left to the highest index on the right
/// then the parameters to this function are lowest index or
/// left and highest index or right. The first time you call
/// this function it will be with the parameters 0, a.length - 1.
/// </remarks>
/// <param name="list">list to sort</param>
/// <param name="l">left boundary of array partition</param>
/// <param name="r">right boundary of array partition</param>
internal void QuickSort(IList <T> list, int l, int r)
{
int M = 4;
int i;
int j;
T v;
if ((r - l) > M)
{
i = (r + l) / 2;
if (Comparer.Compare(list[l], list[i]) > 0)
{
Swapper.Swap(list, l, i); // Tri-Median Methode!
}
if (Comparer.Compare(list[l], list[r]) > 0)
{
Swapper.Swap(list, l, r);
}
if (Comparer.Compare(list[i], list[r]) > 0)
{
Swapper.Swap(list, i, r);
}
j = r - 1;
Swapper.Swap(list, i, j);
i = l;
v = list[j];
for (;;)
{
while (Comparer.Compare(list[++i], v) > 0)
{
}
while (Comparer.Compare(list[--j], v) < 0)
{
}
if (j < i)
{
break;
}
Swapper.Swap(list, i, j);
}
Swapper.Swap(list, i, r - 1);
QuickSort(list, l, j);
QuickSort(list, i + 1, r);
}
}
static void Main(string[] args)
{
List <Box <string> > elements = new List <Box <string> >();
int n = int.Parse(Console.ReadLine());
for (int i = 0; i < n; i++)
{
Box <string> box = new Box <string>(Console.ReadLine());
elements.Add(box);
}
int[] indexes = Console.ReadLine().Split().Select(int.Parse).ToArray();
Swapper <List <string> > .Swap(elements, indexes[0], indexes[1])
.ForEach(e => Console.WriteLine(e));
}
private void Sort2(IList list, int low, int high)
{
int j;
for (j = high; j > low; j--)
{
int i;
for (i = low; i < j; i++)
{
if (Comparer.Compare(list[i], list[i + 1]) > 0)
{
Swapper.Swap(list, i, i + 1);
}
}
}
}
public override void Sort(IList list)
{
bool flipped = true;
int gap;
int top;
int i;
int j;
gap = list.Count;
do
{
if (gap == 2)
{
gap = 1;
}
else
{
gap = (int)(gap / c_COMBOSORTSHRINKFACTOR);
}
switch (gap)
{
case 0:
gap = 1;
break;
case 9:
gap = 11;
break;
case 10:
gap = 11;
break;
}
flipped = false;
top = list.Count - gap;
for (i = 0; i < top; i++)
{
j = i + gap;
if (Comparer.Compare(list[i], list[j]) > 0)
{
Swapper.Swap(list, i, j);
flipped = true;
}
}
} while (flipped || (gap > 1));
}
public override void Sort(IList list)
{
int n;
int i;
n = list.Count;
for (i = n / 2; i > 0; i--)
{
DownHeap(list, i, n);
}
do
{
Swapper.Swap(list, 0, n - 1);
n = n - 1;
DownHeap(list, 1, n);
} while (n > 1);
}
public override void Sort(IList list)
{
var flipped = true;
var gap = list.Count;
do
{
if (gap == 2)
{
gap = 1;
}
else
{
gap = (int)(gap / ComboSortShrinkFactor);
}
switch (gap)
{
case 0:
gap = 1;
break;
case 9:
case 10:
gap = 11;
break;
}
flipped = false;
var top = list.Count - gap;
int i;
for (i = 0; i < top; i++)
{
var j = i + gap;
if (Comparer.Compare(list[i], list[j]) <= 0)
{
continue;
}
Swapper.Swap(list, i, j);
flipped = true;
}
} while (flipped || gap > 1);
}
public void SwapTest()
{
const int ogA = 3;
const int ogB = 9;
var a = ogA;
var b = ogB;
Assert.AreEqual(ogA, a);
Assert.AreEqual(ogB, b);
Assert.AreNotEqual(ogA, b);
Assert.AreNotEqual(ogB, a);
Swapper.Swap(ref a, ref b);
Assert.AreEqual(ogA, b);
Assert.AreEqual(ogB, a);
}
public override void Sort(IList list)
{
int i;
int j;
int min;
for (i = 0; i < list.Count; i++)
{
min = i;
for (j = i + 1; j < list.Count; j++)
{
if (Comparer.Compare(list[j], list[min]) < 0)
{
min = j;
}
}
Swapper.Swap(list, min, i);
}
}
public SortingResult Sort(Data[] array)
{
SortingResult sortingResult = new SortingResult {
ArrayOfData = array
};
var watch = Stopwatch.StartNew();
for (int i = 0; i < array.Length; i++)
{
int ind = GetItem(array, i, sortingResult);
Swapper.Swap(ref array[i], ref array[ind]);
sortingResult.CountOfSwaps++;
}
watch.Stop();
sortingResult.Time = watch.Elapsed;
return(sortingResult);
}
static void NodeTest()
{
Node <int> List = new Node <int>(0);
List.next = new Node <int>(1, List.root);
List++;
List.next = new Node <int>(2, List.root);
List++;
List.next = new Node <int>(3, List.root);
List++;
List.next = new Node <int>(4, List.root);
List++;
List.next = new Node <int>(5, List.root);
List++;
List = List.root;
List.next.Print();
Swapper <int> .Swap(List, List.next);
Console.WriteLine("This is swapp version");
List.next.Print();
}