C++とかC#とか

using System;

namespace ProjectEuler {
    class Problem16 {
        public Problem16() {
            Console.WriteLine(this.ToString());
            BigInt bi = new BigInt(1);
            bi <<= 1000;
            string dec = bi.ToDec();
            int answer = 0;
            foreach (char c in dec) {
                answer += (int)c - (int)'0';
            }
            Console.WriteLine("> " + answer);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace ProjectEuler {
    public class BigInt : ICloneable{
        /// <summary>
        /// 値を表す32ビット値のリスト
        /// 先頭が最も上位を表す
        /// </summary>
        List<UInt32> m_value = new List<UInt32>();

        /// <summary>
        /// 値を表すリストの長さを取得する
        /// </summary>
        public int Length {
            get {
                return m_value.Count;
            }
        }

        public UInt32 this[int n] {
            get {
                return m_value[n];
            }
            set {
                m_value[n] = value;
            }
        }

        /// <summary>
        /// 0で初期化
        /// </summary>
        public BigInt() {
            m_value.Add(0);
        }

        /// <summary>
        /// 32ビット整数で初期化
        /// </summary>
        /// <param name="n"></param>
        public BigInt(UInt32 n) {
            m_value.Add(n);
        }

        int RIndex(int n) {
            return Length - 1 - n;
        }


        /// <summary>
        /// 十進文字列に変換する
        /// </summary>
        /// <returns></returns>
        public string ToDec() {
            StringBuilder ret = new StringBuilder();
            UInt32 mod = 0;
            BigInt bi = BigInt.FromArray(m_value);
            while (true) {
                bi = bi.DivMod10(out mod);
                ret.Insert(0, mod);
                if (bi < 10) {
                    ret.Insert(0, bi.m_value[0]);
                    break;
                }
            }
            return ret.ToString();
        }

        /// <summary>
        /// 32ビット整数の乗算を行う
        /// </summary>
        /// <param name="n"></param>
        public void Multiple(int n) {
            UInt64 v = 0;
            UInt32 u = 0;
            for (int i = 0; i < Length; i++) {
                v = (UInt64)this[RIndex(i)];
                v *= (UInt64)n;
                v += u;
                this[RIndex(i)] = (UInt32)v;
                u = (UInt32)(v>>32);
            }
            if (u != 0) {
                m_value.Insert(0, (UInt32)u);
            }
        }

        /// <summary>
        /// 10で割った時の商と余りを取得する
        /// </summary>
        /// <param name="mod"></param>
        /// <returns></returns>
        public BigInt DivMod10(out UInt32 mod) {
            UInt64 x = 0, m = 0;
            BigInt bi = new BigInt();

            for (int i = 0; i<m_value.Count; i++, x = 0) {
                x = (UInt64)(m_value[i] + (m << 32));
                m = x % 10;
                bi.AppendList((UInt32)(x / 10));
            }
            mod = (UInt32)m;

            return bi;
        }

        /// <summary>
        /// 値を表すリストの末尾に32ビットを追加する
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public BigInt AppendList(UInt32 value) {
            if (m_value[0] == 0) {
                m_value[0] = value;
            } else {
                m_value.Add(value);
            }
            return this;
        }

        /// <summary>
        /// 配列から読み込む
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>
        public static BigInt FromArray(List<UInt32> array) {
            BigInt bi = new BigInt();
            foreach (UInt32 i in array) {
                bi.AppendList(i);
            }
            return bi;
        }

        /// <summary>
        /// 比較
        /// </summary>
        /// <param name="bi"></param>
        /// <param name="a"></param>
        /// <returns></returns>
        public static bool operator <(BigInt bi, int a) {
            if (bi.m_value.Count > 1) {
                return false;
            }
            return bi.m_value[0] < a;
        }

        /// <summary>
        /// 比較
        /// </summary>
        /// <param name="bi"></param>
        /// <param name="a"></param>
        /// <returns></returns>
        public static bool operator >(BigInt bi, int a) {
            if(bi.m_value.Count > 1){
                return true;
            }
            return bi.m_value[0] > a;
        }

        /// <summary>
        /// 左シフト
        /// </summary>
        /// <param name="b"></param>
        /// <param name="shift"></param>
        /// <returns></returns>
        public static BigInt operator <<(BigInt b, int shift) {
            BigInt bi = (BigInt)b.Clone();
            int m = shift / 32,
                n = shift % 32;
            if (n != 0) {
                UInt64 a = 0;
                UInt32 c = 0;
                for (int i = bi.m_value.Count - 1; i >= 0; --i) {
                    a = bi.m_value[i];
                    a <<= n;
                    a |= c;
                    bi.m_value[i] = (UInt32)a;
                    c = (UInt32)(a >> 32);
                }
                if (c != 0) {
                    bi.m_value.Insert(0, c);
                }
            }
            for (int i = 0; i<m;i++ ) {
                bi.AppendList(0);
            }
            return bi;
        }

        #region ICloneable
        public object Clone() {
            BigInt bi = new BigInt();
            foreach (var i in m_value) {
                bi.AppendList(i);
            }
            return bi;
        }
        #endregion
    }
}