public void NumeralShouldGetDigits()
{
#region Arrange
var ulongNum = 29382440;
var bigIntegerNum = new BigInteger(43653452598);
#endregion
#region Act
var ulongDigits = Numeral.GetDigits(ulongNum);
var bigIntegerDigits = Numeral.GetDigits(bigIntegerNum);
#endregion
#region Assert
Assert.AreEqual(8, ulongDigits.Count);
Assert.AreEqual(0, ulongDigits[0]);
Assert.AreEqual(4, ulongDigits[1]);
Assert.AreEqual(4, ulongDigits[2]);
Assert.AreEqual(2, ulongDigits[3]);
Assert.AreEqual(2, ulongDigits[7]);
Assert.AreEqual(11, bigIntegerDigits.Count);
Assert.AreEqual(8, bigIntegerDigits[0]);
Assert.AreEqual(9, bigIntegerDigits[1]);
Assert.AreEqual(6, bigIntegerDigits[8]);
Assert.AreEqual(3, bigIntegerDigits[9]);
Assert.AreEqual(4, bigIntegerDigits[10]);
#endregion
}
static void Main(string[] args)
{
/* NumeralJS style */
PrintLineJS(0, "0.0");
PrintLineJS(1, "0.0");
PrintLineJS(null, "0.0");
PrintLineJS(1, "0.00%");
PrintLineJS(0.47351, "0.0%");
PrintLineJS(0.47351, "0.00%");
PrintLineJS(10059.30, "$0,0.0");
PrintLineJS(1000045023, "$0,0.00a");
Console.WriteLine("***********");
/* C# style */
var numeral = new Numeral("Less than 11", "Zero", null);
PrintLineC(0, "0.0", numeral);
PrintLineC(1, "0.0", numeral);
PrintLineC(null, "0.0", numeral);
PrintLineC(1, "0.00%", numeral);
PrintLineC(0.47351, "0.0%", numeral);
PrintLineC(0.47351, "0.00%", numeral);
PrintLineC(10059.30, "$0,0.0", numeral);
PrintLineC(1000045023, "$0,0.00a", numeral);
}
static BigInteger?GetLychrelPalyndrome(int n)
{
var iterationsCount = 0;
var number = new Numeral(n);
var reverse = new Numeral(0);
var sum = new Numeral(0);
while (iterationsCount < MAX_ITERATIONS && !number.IsPalyndrome())
{
while (reverse.Digits.Count < number.Digits.Count)
{
reverse.Digits.Add(0);
}
for (int i = 0; i < number.Digits.Count; i++)
{
reverse.Digits[reverse.Digits.Count - 1 - i] = number.Digits[i];
}
Numeral.Sum(number, reverse, sum);
var tmp = number;
number = sum;
sum = reverse;
reverse = tmp;
iterationsCount++;
}
if (iterationsCount == MAX_ITERATIONS)
{
return(null);
}
return(number.GetBigInteger());
}
private static string ConvertNumberUnderThousand(Numeral numeral, int number)
{
if (numeral != Numeral.One && number == 1)
return string.Empty;
var result = new StringBuilder();
var hundreds = number / 100;
if (hundreds > 0)
{
var map = new[] { "", "sto", "dwieście", "trzysta", "czterysta", "pięćset", "sześćset", "siedemset", "osiemset", "dziewięćset" };
result.AppendFormat(@"{0} ", map[hundreds]);
number = number % 100;
}
var tens = number / 10;
if (tens > 1)
{
var map = new[] { "", "dziesięć", "dwadzieścia", "trzydzieści", "czterdzieści", "pięćdziesiąt", "sześćdziesiąt", "siedemdziesiąt", "osiemdziesiąt", "dziewięćdziesiąt" };
result.AppendFormat(@"{0} ", map[tens]);
number = number % 10;
}
if (number > 0)
{
var map = new[] { "zero", "jeden", "dwa", "trzy", "cztery", "pięć", "sześć", "siedem", "osiem", "dziewięć", "dziesięć", "jedenaście", "dwanaście", "trzynaście", "czternaście", "piętnaście", "szesnaście", "siedemnaście", "osiemnaście", "dziewiętnaście" };
result.AppendFormat(@"{0} ", map[number]);
}
return result.ToString();
}
private static void NumberToNumeral()
{
Console.WriteLine(
@"|------| Number to Numeral Conversion |------|");
while (true)
{
Console.WriteLine("\nEnter a number to convert or 'B' to go back");
Console.Write("> ");
var userInput = Console.ReadLine()?.ToUpper();
if (userInput != null && userInput.StartsWith("B"))
{
break;
}
int.TryParse(userInput, out var numberToConvert);
try
{
var numeral = new Numeral(numberToConvert);
Console.WriteLine($"\n{numeral.ArabicValue} : {numeral.RomanValue}");
}
catch (ArgumentException e)
{
Console.WriteLine(e.Message);
}
}
}
static void PrintLineC(double?value, string format, Numeral numeral)
{
var output = numeral.Format(value, format);
Console.WriteLine(
string.Format("({0}, {1}) => {2}", value, format, output)
);
}
static void PrintLineJS(double?value, string format)
{
var numeral = new Numeral(value);
var output = numeral.Format(format);
Console.WriteLine(
string.Format("({0}, {1}) => {2}", value, format, output)
);
}
public void Creating_Valid_Numerals_Does_Not_Throw_Exceptions()
{
var sut = new Numeral("MM");
sut = new Numeral("II");
sut = new Numeral("XIX");
sut = new Numeral("MMMCLII");
sut = new Numeral("CCI");
}
public static Type GetType(int elementCount)
{
if (elementCount < 0)
{
throw new ArgumentOutOfRangeException(nameof(elementCount));
}
var numeral = Numeral <T> .GetNType(elementCount);
return(typeof(FixedArray <,>).MakeGenericType(numeral, typeof(T)));
}
public void A_Numeral_Can_Be_Built_with_Tens()
{
//Given
var sut = new Numeral(2790);
//When
var expected = "MMDCCXC";
//Then
Assert.Equal(expected, sut.RomanValue);
}
public void NounProcessNumeral()
{
var num = new Numeral(2, "3", "nummod");
var elem = this.Noun.Process(num, this.SentenceGraph);
Assert.IsInstanceOfType(elem, typeof(NounSet));
this.Noun.DependencyType = "nmod:npmod";
this.Noun.Process(num, this.SentenceGraph);
Assert.IsTrue(this.Noun.Extensions[0] == num);
}
internal static void Point(Numeral x, Numeral y)
{
Tuple <Numeral, Numeral> point1 = ChurchTuple <Numeral, Numeral> .Create(x)(y);
Numeral x1 = point1.Item1();
Numeral y1 = point1.Item1();
// Move up.
Numeral y2 = y1.Increase();
Tuple <Numeral, Numeral> point2 = ChurchTuple <Numeral, Numeral> .Create(x1)(y2);
}
public void DecreaseTest()
{
Numeral numeral = 3U.Church();
Assert.AreEqual(3U - 1U, (numeral = numeral.Decrease()).Unchurch());
Assert.AreEqual(2U - 1U, (numeral = numeral.Decrease()).Unchurch());
Assert.AreEqual(1U - 1U, (numeral = numeral.Decrease()).Unchurch());
Assert.AreEqual(0U, (numeral = numeral.Decrease()).Unchurch());
numeral = 123U.Church();
Assert.AreEqual(123U - 1U, numeral.Decrease().Unchurch());
}
public void IncreaseTest()
{
Numeral numeral = 0U.Church();
Assert.AreEqual(0U + 1U, (numeral = numeral.Increase()).Unchurch());
Assert.AreEqual(1U + 1U, (numeral = numeral.Increase()).Unchurch());
Assert.AreEqual(2U + 1U, (numeral = numeral.Increase()).Unchurch());
Assert.AreEqual(3U + 1U, (numeral = numeral.Increase()).Unchurch());
numeral = 123U.Church();
Assert.AreEqual(123U + 1U, numeral.Increase().Unchurch());
}
public void A_Numeral_Can_Be_Built_with_Hundreds()
{
//Given
var sut = new Numeral(1400);
//When
var expected = "MCD";
//Then
Assert.Equal(expected, sut.RomanValue);
}
public void A_Numeral_Can_Be_Built_with_Ones()
{
//Given
var sut = new Numeral(683);
//When
var expected = "DCLXXXIII";
//Then
Assert.Equal(expected, sut.RomanValue);
}
public void A_Numeral_Can_Be_Built_with_thousands()
{
//Given
var sut = new Numeral(3000);
//When
var expected = "MMM";
//Then
Assert.Equal(expected, sut.RomanValue);
}
public void Subtractive_Notation_Works_As_Expected()
{
//Given
var sut = new Numeral("CMXLIX");
var expectedInt = 949;
//When
var actualInt = sut.ArabicValue;
//Then
Assert.Equal(expectedInt, actualInt);
}
public void Passing_Numerals_As_A_String_Gives_Correct_Value()
{
//Given
var sut = new Numeral("XXII");
var expectedInt = 22;
//When
var actualInt = sut.ArabicValue;
//Then
Assert.Equal(expectedInt, actualInt);
}
public void NounSetProcessNumeral()
{
var num = new Numeral(2, "5", "nummod");
this.NounSet.Process(num, this.SentenceGraph);
this.NounSet.FinalizeProcessing(this.SentenceGraph);
Assert.AreEqual(this.NounSet.Nouns.Count(), 5);
num.DependencyType = "nmod:npmod";
this.NounSet.Process(num, this.SentenceGraph);
this.NounSet.Nouns.ForEach(n =>
{
Assert.IsTrue(n.Suffixes[0] == num);
});
}
public void A_Numeral_Initialised_With_Lowercase_Char_Is_Valid()
{
//Given
var sut = new Numeral('d');
var expectedString = "D";
var expectedInt = 500;
//When
var actualString = sut.RomanValue;
var actualInt = sut.ArabicValue;
//Then
Assert.Equal(expectedString, actualString);
Assert.Equal(expectedInt, actualInt);
}
public void Numeral_D_Has_A_Value_Of_500()
{
//Given
var sut = new Numeral('D');
var expectedString = "D";
var expectedInt = 500;
//When
var actualString = sut.RomanValue;
var actualInt = sut.ArabicValue;
//Then
Assert.Equal(expectedString, actualString);
Assert.Equal(expectedInt, actualInt);
}
public void Numeral_I_Has_A_Value_Of_1()
{
//Given
var sut = new Numeral("I");
var expectedString = "I";
var expectedInt = 1;
//When
var actualString = sut.RomanValue;
var actualInt = sut.ArabicValue;
//Then
Assert.Equal(expectedString, actualString);
Assert.Equal(expectedInt, actualInt);
}
/// <summary>
/// Method for creating new text elements
/// </summary>
/// <param name="parts">UDPipe service response line</param>
/// <returns>New text element</returns>
public IProcessable Create(string[] parts)
{
// Map known cases
this.MapKnownCases(parts[2], ref parts[3]);
IProcessable part = null;
switch (parts[3])
{
case "PROPN":
case "NOUN":
part = this.ProcessNoun(parts);
break;
case "ADJ":
part = this.ProcessAdj(parts);
break;
case "ADP":
part = new Adposition(int.Parse(parts[0]), parts[2], parts[7]);
break;
case "NUM":
part = new Numeral(int.Parse(parts[0]), parts[2], parts[7]);
break;
case "VERB":
part = this.ProcessVerb(parts);
break;
case "ADV":
part = new Adverb(int.Parse(parts[0]), parts[2], parts[7]);
break;
case "CONJ":
part = new Coordination(int.Parse(parts[0]), parts[2], parts[7]);
break;
case "NEG":
part = new Negation(int.Parse(parts[0]), parts[2], parts[7]);
break;
default:
break;
}
return(part);
}
public static string AttributeToString(this Numeral attribute)
{
var spirit = GameData.Instance.Player.PlayerInputSystem.ChoosedSpirit.Data;
var withPercent =
attribute == Numeral.ItemDropRate ||
attribute == Numeral.ItemQualityRate ||
attribute == Numeral.BuffTime ||
attribute == Numeral.DebuffTime;
if (attribute == Numeral.Level)
{
return($"{Uty.KiloFormat((int)spirit.Get(attribute).Sum)}");
}
return($"{Uty.KiloFormat(spirit.Get(attribute).Sum)}{(withPercent ? "%" : string.Empty)}");
}
public void NumeralShouldRetainValue()
{
#region Arrange
var n1 = new BigInteger(234235);
var n2 = 478365;
#endregion
#region Act
var num1 = new Numeral(n1);
var num2 = new Numeral(n2);
var nn1 = num1.GetBigInteger();
var nn2 = num2.GetBigInteger();
#endregion
#region Assert
Assert.AreEqual(n1, nn1);
Assert.AreEqual(n2, nn2);
#endregion
}
//WEIGHTED GRAPH CHOICE
//TODO: Move Generic Version of this to Util Class
public Numeral Next()
{
Numeral selected = this.Name;
// if we fail to make a selection, return this chord
// totalWeight is the sum of all edges weight
float randomNumber = UnityEngine.Random.Range(0f, _totalWeight);
foreach (Edge edge in _edges)
{
if (randomNumber <= edge.Weight)
{
selected = edge.Name;
break;
}
randomNumber = randomNumber - edge.Weight;
}
return(selected);
}
public static void Run(Input input, Output output)
{
var meta = input.ReadLine().Split(' ');
var N = int.Parse(meta[0]);
var K = int.Parse(meta[1]);
var cubesPermutations =
new Dictionary <CubePermutationKey, CubePermutationData>();
for (long i = 1; i < N; i++)
{
long cube = i * i * i;
var cubeDigits = Numeral.GetDigits((ulong)cube);
var currKey = new CubePermutationKey();
for (int currDigitIndex = 0; currDigitIndex < cubeDigits.Count; currDigitIndex++)
{
currKey.Digits[cubeDigits[currDigitIndex]]++;
}
currKey.InitHash();
if (!cubesPermutations.ContainsKey(currKey))
{
cubesPermutations.Add(currKey, new CubePermutationData()
{
Smallest = cube, Count = 1
});
}
else
{
cubesPermutations[currKey].Count++;
}
}
foreach (var val in cubesPermutations.Values)
{
if (val.Count == K)
{
output.WriteLine(val.Smallest.ToString());
}
}
}
static void Main(string[] args)
{
Numeral actual = new Numeral();
var guessCount = 1;
var correctGuess = false;
while (guessCount <= 10 && !correctGuess)
{
Console.Write($"Guess #{guessCount}. Enter a 4 digit string and press enter: ");
var guessString = Console.ReadLine();
if (GuessIsValid(guessString))
{
Numeral guess = new Numeral(guessString);
if (guess.FourDigitString == actual.FourDigitString)
{
correctGuess = true;
}
else
{
string numeralComparison = CompareGuessNumeralToActualNumeral(guess.FourDigitString, actual.FourDigitString);
Console.WriteLine(numeralComparison);
}
guessCount++;
}
else
{
Console.WriteLine($"Invalid guess - must be a 4 digit string with each digit between 1 and 6");
}
}
Console.WriteLine("Actual number: " + actual.FourDigitString);
if (correctGuess)
{
Console.WriteLine("You win!");
}
else
{
Console.WriteLine("Sorry, you lose!");
}
}
public static NestedListNode <T> NodeAt <T>(this NestedListNode <T> start, Numeral index) => ChurchNestedList <T> .NodeAt(start)(index);
private static string GetSuffix(Numeral numeral, int num)
{
switch (numeral)
{
case Numeral.Miliard:
var miliard = new[] { "miliard", "miliardy", "miliardów" }; //one, denominator, genitive
return miliard[GetMappingIndex(num)];
case Numeral.Million:
var million = new[] { "milion", "miliony", "milionów" }; //one, denominator, genitive
return million[GetMappingIndex(num)];
case Numeral.Thousand:
var thousand = new[] { "tysiąc", "tysiące", "tysięcy" }; //one, denominator, genitive
return thousand[GetMappingIndex(num)];
default:
return string.Empty;
}
}
public Transaction(Commodity.Commodity commodity, Numeral <TDigit> number)
{
Commodity = commodity;
Number = number;
}
