public static LargeNumberModel operator +(LargeNumberModel left, LargeNumberModel right)
{
LargeNumberModel bigger = left.NumberLength >= right.NumberLength ? left : right;
LargeNumberModel smaller = left.NumberLength < right.NumberLength ? left : right;
List <int> result = new List <int>();
int highdigit = 0;
for (int i = bigger.NumberLength - 1, m = smaller.NumberLength - 1; i >= 0; i--, m--)
{
if (m >= 0)
{
int digit = smaller.Digits[m] + bigger.Digits[i] + highdigit;
result.Add(digit % 10);
highdigit = digit / 10;
continue;
}
int digitb = bigger.Digits[i] + highdigit;
result.Add(digitb % 10);
highdigit = digitb / 10;
}
if (highdigit > 0)
{
result.Add(highdigit);
}
LargeNumberModel resultNum = new LargeNumberModel();
result.Reverse();
resultNum.Digits = result.ToArray();
return(resultNum);
}
public LargeNumberModel NextLargeNumber()
{
LargeNumberModel temp = secondLNum;
secondLNum = firstLNum + secondLNum;
firstLNum = temp;
return secondLNum;
}
public static LargeNumberModel operator *(LargeNumberModel left, int right)
{
List <int> result = new List <int>();
int highdigit = 0;
for (int i = left.NumberLength - 1; i >= 0; i--)
{
int digit = left.Digits[i] * right + highdigit;
result.Add(digit % 10);
highdigit = digit / 10;
}
while (highdigit > 10)
{
result.Add(highdigit % 10);
highdigit = (highdigit / 10);
}
if (highdigit > 0)
{
result.Add(highdigit);
}
LargeNumberModel resultNum = new LargeNumberModel();
result.Reverse();
resultNum.Digits = result.ToArray();
return(resultNum);
}
static bool CheckPalindromic(LargeNumberModel number)
{
string reverse = ReverseNumber(number).ToString();
if (string.Equals(number.ToString(),reverse))
return true;
return false;
}
static LargeNumberModel Cube(int num)
{
LargeNumberModel result = new LargeNumberModel(num.ToString());
result = result * num;
result = result * num;
return result;
}
public static LargeNumberModel operator *(LargeNumberModel left, LargeNumberModel right)
{
LargeNumberModel result = new LargeNumberModel("0");
for (int i = 0; i < right.NumberLength; i++)
{
result = result + left * (right.Digits[i] * (int)Math.Pow(10, right.NumberLength - i - 1));
}
return result;
}
public static LargeNumberModel operator *(LargeNumberModel left, LargeNumberModel right)
{
LargeNumberModel result = new LargeNumberModel("0");
for (int i = 0; i < right.NumberLength; i++)
{
result = result + left * (right.Digits[i] * (int)Math.Pow(10, right.NumberLength - i - 1));
}
return(result);
}
static bool CanGetPalindromicIn50Cycles(LargeNumberModel number)
{
LargeNumberModel temp = new LargeNumberModel(number.ToString());
for (int i = 0; i < 50; i++)
{
LargeNumberModel reverse = ReverseNumber(temp);
LargeNumberModel sum = temp + reverse;
if (CheckPalindromic(sum))
return true;
temp = sum;
}
return false;
}
static void Main(string[] args)
{
string matrixNumbers = FileReader.ReadFile("Nums.txt", System.Text.Encoding.UTF8);
string[] nums = matrixNumbers.Replace("\r\n", "|").Split('|');
LargeNumberModel result = new LargeNumberModel("0");
foreach (string num in nums)
{
LargeNumberModel ln = new LargeNumberModel(num);
result = result + ln;
}
Console.WriteLine(result.ToString().Substring(0,10));
Debug.WriteLine(result.ToString().Substring(0, 10));
Console.Read();
}
static LargeNumberModel SeriesSum(int max)
{
LargeNumberModel result = new LargeNumberModel("0");
for (int i = 1; i <= max; i++)
{
LargeNumberModel num = new LargeNumberModel(i.ToString());
for (int j = 0; j < i - 1; j++)
{
num = num * i;
}
result = result + num;
}
return result;
}
static void Main(string[] args)
{
LargeNumberModel num = new LargeNumberModel("2"); // 11930336
for (int i = 1; i < 1000; i++ )
num = num * 2;
Console.WriteLine(num);
string result = num.ToString();
int sum = 0;
for (int i = 0; i < result.Length; i++)
{
sum += int.Parse(result.Substring(i, 1));
}
Console.WriteLine(string.Format("sum:{0}",sum));
Console.Read();
}
static void Main(string[] args)
{
LargeNumberModel num = new LargeNumberModel("1");
for (int i = 2; i <= 100; i++)
{
num = num * i;
}
int result = 0;
foreach (int i in num.Digits)
{
result += i;
}
Console.WriteLine(result);
Console.ReadLine();
}
static LargeNumberModel Pow(LargeNumberModel num, int pow)
{
if (pow < 0)
throw new ApplicationException("Pow can not be smaller than 0");
if (pow == 0)
return new LargeNumberModel("1");
if (pow == 1)
return num;
LargeNumberModel result = new LargeNumberModel(num.ToString());
int basenum = int.Parse(num.ToString());
for (int i = 1; i < pow; i++)
{
result = result * basenum;
}
return result;
}
public override bool Equals(object obj)
{
LargeNumberModel item = (LargeNumberModel)obj;
if (this.NumberLength != item.NumberLength)
{
return(false);
}
for (int i = 0; i < this.NumberLength; i++)
{
if (this.Digits[i] != item.Digits[i])
{
return(false);
}
}
return(true);
}
static void Main(string[] args)
{
int count = 0;
for (int i = 1; i <= 9; i++)
{
LargeNumberModel num = new LargeNumberModel(i.ToString());
int pow = 1;
while (true)
{
if (num.NumberLength != pow)
break;
num = num * i;
count++;
pow++;
}
}
Console.WriteLine(string.Format("result is {0}", count));
}
static void Main(string[] args)
{
int result = 0;
for (int a = 1; a < 100; a++)
{
for (int b = 1; b < 100; b++)
{
LargeNumberModel la = new LargeNumberModel(a.ToString());
LargeNumberModel powresult = Pow(la, b);
int digitalSum = powresult.Digits.Sum();
if (digitalSum > result)
result = digitalSum;
Console.WriteLine("{0} ^ {1} = {2} ; digital sum = {3}", a, b, powresult.ToString(), digitalSum);
}
}
Console.WriteLine("Result is {0}", result);
}
public static LargeNumberModel operator ++(LargeNumberModel left)
{
List <int> result = new List <int>();
int highdigit = 1;
for (int i = left.NumberLength - 1; i >= 0; i--)
{
int digitb = left.Digits[i] + highdigit;
result.Add(digitb % 10);
highdigit = digitb / 10;
}
if (highdigit > 0)
{
result.Add(highdigit);
}
LargeNumberModel resultNum = new LargeNumberModel();
result.Reverse();
resultNum.Digits = result.ToArray();
return(resultNum);
}
public static LargeNumberModel operator *(LargeNumberModel left, int right)
{
List<int> result = new List<int>();
int highdigit = 0;
for (int i = left.NumberLength - 1 ; i >= 0; i--)
{
int digit = left.Digits[i] * right + highdigit;
result.Add(digit % 10);
highdigit = digit / 10;
}
while (highdigit > 10)
{
result.Add(highdigit % 10);
highdigit = (highdigit / 10);
}
if (highdigit > 0)
{
result.Add(highdigit);
}
LargeNumberModel resultNum = new LargeNumberModel();
result.Reverse();
resultNum.Digits = result.ToArray();
return resultNum;
}
public static LargeNumberModel operator ++(LargeNumberModel left)
{
List<int> result = new List<int>();
int highdigit = 1;
for (int i = left.NumberLength - 1; i >= 0; i--)
{
int digitb = left.Digits[i] + highdigit;
result.Add(digitb % 10);
highdigit = digitb / 10;
}
if (highdigit > 0)
result.Add(highdigit);
LargeNumberModel resultNum = new LargeNumberModel();
result.Reverse();
resultNum.Digits = result.ToArray();
return resultNum;
}
static LargeNumberModel ReverseNumber( LargeNumberModel number)
{
LargeNumberModel result = new LargeNumberModel();
result.Digits = number.Digits.Reverse().ToArray();
return result;
}
static string SignNum(LargeNumberModel num)
{
string numStr = num.ToString();
return new string(numStr.OrderBy(x => x).ToArray());
}
public static LargeNumberModel operator +(LargeNumberModel left, LargeNumberModel right)
{
LargeNumberModel bigger = left.NumberLength >= right.NumberLength ? left : right;
LargeNumberModel smaller = left.NumberLength < right.NumberLength ? left : right;
List<int> result = new List<int>();
int highdigit = 0;
for (int i = bigger.NumberLength - 1, m = smaller.NumberLength - 1; i >= 0; i--, m--)
{
if (m >= 0)
{
int digit = smaller.Digits[m] + bigger.Digits[i] + highdigit;
result.Add(digit % 10);
highdigit = digit / 10;
continue;
}
int digitb = bigger.Digits[i] + highdigit;
result.Add(digitb % 10);
highdigit = digitb / 10;
}
if (highdigit > 0)
result.Add(highdigit);
LargeNumberModel resultNum = new LargeNumberModel();
result.Reverse();
resultNum.Digits = result.ToArray();
return resultNum;
}
