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; }