1一直乘到100是多少？ 求编码。

Sheldon

981013

Sheldon 发表于 2014-12-5 21:00
那1一直乘到10呢？

[mw_shl_code=c,true]#include <stdio.h>
#include <stdlib.h>
int main()
{
    int r=1,a;
    for (a=1; a<=10; ++a)
        r*=a;
    printf("%d",r);
}[/mw_shl_code]

rosynirvana

如果你是要求精确值，那内置的数据类型放不下，要自己写

981013

上段C++：
[mw_shl_code=c,true]//  longlonglong.h
#ifndef __longlonglong__longlonglong__
#define __longlonglong__longlonglong__
#include <iostream>
#include <vector>
#include <string>
class longlonglong
{
private:
    std::vector<short> m_vDigits;
    bool m_bNegative;
public:
    longlonglong()=default;
    longlonglong(const longlonglong& other):m_vDigits(other.m_vDigits),m_bNegative(other.m_bNegative){};
    /**
     @brief 用作为字符串的数字构造longlonglong型对象
     @param numberString 作为字符串的数字
     */
    longlonglong(const std::string& numberString);
    /**
     @brief 用long long型的数字构造longlonglong型对象
     @param num long long型的数字
     @param autozero 用于控制是否将空数字自动转化为0
     @note  也可以用于int型数字
     */
    longlonglong(const long long& num,bool autozero=true);
    /**
     @brief 用std::vector<short>构造longlonglong型对象
     @param num 每个元素代表一位数字
     @param reverse 若为false,则num[0]为最高位,否则num[last]为最高位
     */
    longlonglong(const std::vector<short>& num,bool reverse=false);
    longlonglong& operator = (const longlonglong& other)
    {
        m_bNegative = other.m_bNegative;
        m_vDigits=other.m_vDigits;
        return *this;
    }
    /**
     @brief 算术操作+
     @param a 被加数
     @param b 加数
     */
    friend longlonglong operator + (const longlonglong& a,const longlonglong& b);
    /**
     @brief 算术操作-
     @param a 被减数
     @param b 减数
     */
    friend longlonglong operator - (const longlonglong& a,const longlonglong& b);
    /**
     @brief 算术操作*
     @param a 被乘数
     @param b 乘数
     */
    friend longlonglong operator * (const longlonglong& a,const longlonglong& b);
    /**
     @brief 算术操作/
     @param a 被除数
     @param b 除数
     */
    friend longlonglong operator / (const longlonglong& a,const longlonglong& b);
    /**
     @brief 算术操作%
     @param a 被除数
     @param b 除数
     */
    friend longlonglong operator % (const longlonglong& a,const longlonglong& b);
    /**
     @brief 算术操作^
     @param a 底数
     @param b 指数
     */
    friend longlonglong operator ^ (const longlonglong& a,const longlonglong& b);
    /**
     @brief 取负运算符
     */
    longlonglong operator -() const;
    /**以下为算数赋值运算符*/
    longlonglong& operator += (const longlonglong& other);
    longlonglong& operator -= (const longlonglong& other);
    longlonglong& operator *= (const longlonglong& other);
    longlonglong& operator /= (const longlonglong& other);
    longlonglong& operator %= (const longlonglong& other);
    longlonglong& operator ^= (const longlonglong& other);
    longlonglong& operator ++ ();
    longlonglong operator ++ (int);
    longlonglong& operator -- ();
    longlonglong operator -- (int);
    /*******************************************************/
    /**
     @brief 强制转化到bool，方便对==0的判断
     */
    operator bool() const;
    /**以下为逻辑判断运算符*/
    friend bool operator == (const longlonglong& a,const longlonglong& b);
    friend bool operator != (const longlonglong& a,const longlonglong& b);
    friend bool operator > (const longlonglong& a,const longlonglong& b);
    friend bool operator < (const longlonglong& a,const longlonglong& b);
    friend bool operator >= (const longlonglong& a,const longlonglong& b);
    friend bool operator <= (const longlonglong& a,const longlonglong& b);
    /********************************************************************/
    friend longlonglong abs(const longlonglong& num)
    {
        longlonglong ret(num);
        ret.m_bNegative=false;
        return ret;
    }
    /**
     @brief 向输出流中插入数据
     @param num 插入的数据
     */
    friend std:stream& operator << (std:stream& os,const longlonglong& num);
    /**
     @brief 从输入流中获取数据
     @param num 插入的数据
     */
    friend std::istream& operator >> (std::istream& is,longlonglong& num);
private:
    /**
     @brief 辅助函数，整理数据结构
     */
    void Reorganization();

};

#endif /* defined(__longlonglong__longlonglong__) */
[/mw_shl_code]
[mw_shl_code=c,true]//  longlonglong.cpp


#include "longlonglong.h"
#include <algorithm>
#include <cassert>
longlonglong::longlonglong(const std::string& numberString)
{
    if (numberString[0]=='-')
        m_bNegative=true;
    else
        m_bNegative=false;
    if(numberString.empty())
    {
        m_vDigits.push_back(0);
        return;
    }
    for(auto a=numberString[0]=='-'||numberString[0]=='+'?numberString.rbegin()+1:numberString.rbegin(); a!=numberString.rend(); ++a)
    {
        auto digit=*a;
        m_vDigits.push_back(digit-'0');
    }
}
longlonglong::longlonglong(const long long& num,bool autozero)
{
    if(num<0)
        m_bNegative=true;
    else
        m_bNegative=false;
    if(num==0&&autozero)
    {
        m_vDigits.push_back(0);
        return;
    }
    auto n=num>0?num:-num;
    while (n!=0)
    {
        m_vDigits.push_back(n%10);
        n/=10;
    }
}
longlonglong::longlonglong(const std::vector<short>& num,bool reverse):m_vDigits(num),m_bNegative(false)
{
    if (reverse)
        std::reverse(m_vDigits.begin(), m_vDigits.end());
}
longlonglong operator + (const longlonglong& a,const longlonglong& b)
{
    longlonglong ret(a);
    ret+=b;
    return ret;
}
longlonglong operator - (const longlonglong& a,const longlonglong& b)
{
    longlonglong ret(a);
    ret-=b;
    return ret;
}
longlonglong operator * (const longlonglong& a,const longlonglong& b)
{
    longlonglong ret;
    ret.m_vDigits=std::vector<short>(a.m_vDigits.size()+b.m_vDigits.size(),0);
    for (size_t l=0; l<a.m_vDigits.size(); ++l)
        for (size_t m=0; m<b.m_vDigits.size(); ++m)
            ret.m_vDigits[l+m]+=a.m_vDigits[l]*b.m_vDigits[m];
    ret.m_bNegative=(a.m_bNegative!=b.m_bNegative);
    ret.Reorganization();
    return ret;
}
longlonglong operator / (const longlonglong& a,const longlonglong& b)
{
    assert(b!=longlonglong(0));
    if(a.m_vDigits.size()<b.m_vDigits.size())
        return 0;
    if(b==longlonglong(1))
        return a;
    longlonglong left(0,false);
    longlonglong result(0,false);
    if(a<longlonglong(0)||b<longlonglong(0))
        result=abs(a)/abs(b);
    else
    {
        result.m_vDigits=std::vector<short>(a.m_vDigits.size()-b.m_vDigits.size()+1,0);
        size_t loc=a.m_vDigits.size()-b.m_vDigits.size();
        size_t takeing=a.m_vDigits.size()-1;
        for (size_t t=1; t<=b.m_vDigits.size(); ++t,--takeing)
            left.m_vDigits.push_back(a.m_vDigits[takeing]);
        std::reverse(left.m_vDigits.begin(), left.m_vDigits.end());
        while (takeing!=-1)
        {
            short r;
            for (r=9; longlonglong(r)*abs(b)>left; --r)
                ;
            result.m_vDigits[loc]=r;
            left-=longlonglong(r)*b;
            left.m_vDigits.insert(left.m_vDigits.begin(), a.m_vDigits[takeing--]);
            left.Reorganization();
            --loc;
        }
        short r;
        for (r=9; longlonglong(r)*abs(b)>left; --r)
            ;
        result.m_vDigits[loc]=r;
    }
    result.m_bNegative=(a.m_bNegative!=b.m_bNegative);
    result.Reorganization();
    return result;
}
longlonglong operator % (const longlonglong& a,const longlonglong& b)
{
    return a-(a/b)*b;
}
longlonglong operator ^ (const longlonglong& a,const longlonglong& b)
{
    longlonglong ret=a;
    if(b==longlonglong(0))
        return 1;
    for (auto tp=b; tp>longlonglong(1); --tp)
        ret*=a;
    return ret;
}
longlonglong longlonglong:perator - () const
{
    auto ret(*this);
    ret.m_bNegative=!ret.m_bNegative;
    return ret;
}
longlonglong& longlonglong:perator += (const longlonglong& other)
{
    if(m_bNegative&&other.m_bNegative)
    {
        auto tp=(-*this)+(-other);
        return *this=-tp;
    }
    else if (m_bNegative)
        return *this=other+(*this);
    else if (other.m_bNegative)
        return *this-=(-other);
    else
    {
        while(other.m_vDigits.size()>m_vDigits.size())//当位数小于加数时在最高位补0
            m_vDigits.push_back(0);
        for(size_t a=0; a<m_vDigits.size()&&a<other.m_vDigits.size(); ++a)
            m_vDigits[a]+=other.m_vDigits[a];
        Reorganization();
        return *this;
    }
}
longlonglong& longlonglong:perator -= (const longlonglong& other)
{
    if(other.m_bNegative)
        return *this+=(-other);
    else if (m_bNegative)
        return *this=-((-(*this))+other);
    else if (*this<other)
        return *this=-(other-*this);
    else
    {
        while(other.m_vDigits.size()>=m_vDigits.size())//当位数小于减数时在最高位补0
            m_vDigits.push_back(0);
        for(size_t a=0; a<other.m_vDigits.size(); ++a)
        {
            while (m_vDigits[a]<other.m_vDigits[a])
                m_vDigits[a]+=10,m_vDigits[a+1]-=1;
            m_vDigits[a]-=other.m_vDigits[a];
        }
        Reorganization();
        return *this;
    }
}
longlonglong& longlonglong:perator *= (const longlonglong& other)
{
    return *this=*this*other;
}
longlonglong& longlonglong:perator /= (const longlonglong& other)
{
    return *this=*this/other;
}
longlonglong& longlonglong:perator %= (const longlonglong& other)
{
    return *this=*this%other;
}
longlonglong& longlonglong:perator ^= (const longlonglong& other)
{
    return *this=*this^other;
}
longlonglong& longlonglong:perator ++ ()
{
    return *this+=1;
}
longlonglong longlonglong::operator ++ (int)
{
    auto ret=*this;
    *this+=1;
    return ret;
}
longlonglong& longlonglong::operator -- ()
{
    return *this-=1;
}
longlonglong longlonglong::operator -- (int)
{
    auto ret=*this;
    *this-=1;
    return ret;
}
longlonglong::operator bool() const
{
    return *this==longlonglong(0);
}
bool operator == (const longlonglong& a,const longlonglong& b)
{
    if((a.m_bNegative!=b.m_bNegative)||(a.m_vDigits.size()!=b.m_vDigits.size()))
        return false;
    for (size_t s=0; s<a.m_vDigits.size(); ++s)
        if (a.m_vDigits!=b.m_vDigits)
            return false;
    return true;
}
bool operator != (const longlonglong& a,const longlonglong& b)
{
    return !(a==b);
}
bool operator > (const longlonglong& a,const longlonglong& b)
{
    return !(a<=b);
}
bool operator < (const longlonglong& a,const longlonglong& b)
{
    if(a.m_bNegative&&!b.m_bNegative)
        return true;
    else if(b.m_bNegative&&!a.m_bNegative)
        return false;
    else if(a.m_bNegative&&b.m_bNegative)
        return !((-a)>=(-b));
    else
    {
        if (a.m_vDigits.size()<b.m_vDigits.size())
            return true;
        else if(a.m_vDigits.size()>b.m_vDigits.size())
            return false;
        else
        {
            for (auto ela=a.m_vDigits.rbegin(),elb=b.m_vDigits.rbegin(); ela!=a.m_vDigits.rend()&&elb!=b.m_vDigits.rend(); ++ela,++elb)
            {
                if ((*ela)>(*elb))
                    return false;
                else if ((*ela)<(*elb))
                    return true;
            }
        }
    }
    return false;
}
bool operator >= (const longlonglong& a,const longlonglong& b)
{
    return !(a<b);
}
bool operator <= (const longlonglong& a,const longlonglong& b)
{
    return (a<b)||(a==b);
}
std::ostream& operator << (std::ostream& os,const longlonglong& num)
{
    if (num.m_bNegative)
        os<<'-';
    for (auto loc=num.m_vDigits.rbegin(); loc!=num.m_vDigits.rend(); ++loc)
        os<<*loc;
    return os;
}
std::istream& operator >> (std::istream& is,longlonglong& num)
{
    std::string n;
    char ch;
    while (1)
    {
        ch=is.get();
        if(!isdigit(ch))
        {
            is.unget();
            break;
        }
        else
            n+=ch;
    }
    num=longlonglong(n);
    return is;
}
void longlonglong::Reorganization()
{
    for (auto a=m_vDigits.rbegin(); a!=m_vDigits.rend()-1; ++a)
    {
        while((*a)<0)
        {
            *a+=10;
            --*(a-1);
        }
    }
    if(*(m_vDigits.rbegin())<0)//改变符号
    {
        m_bNegative=!m_bNegative;
        *(m_vDigits.rbegin())=9-*(m_vDigits.rbegin());
    }
    for (auto a=m_vDigits.begin(); a!=m_vDigits.end()-1; ++a)//进位
        if(*a>=10)
        {
            *(a+1)+=*a/10;
            *a%=10;
        }
    while (*(m_vDigits.end()-1)>=10)//最高位进位
    {
        m_vDigits.push_back(*(m_vDigits.end()-1)/10);
        *(m_vDigits.end()-2)%=10;
    }
    for (auto a=m_vDigits.end()-1; a!=m_vDigits.begin()-1; --a)
    {
        if(!*a)
            m_vDigits.erase(a);
        else
            break;
    }
    if(m_vDigits.size()==1&&m_vDigits[0]==0)
        m_bNegative=false;
    if(m_vDigits.empty())
    {
        m_vDigits.push_back(0);
        m_bNegative=false;
    }
}

[/mw_shl_code]
[mw_shl_code=c,true]//main.cpp
#include "longlonglong.h"
using namespace std;
int main()
{
    longlonglong a(1);
    int b;
    for(b=1;b<=100;++b)
        a*=longlonglong(b);
    cout<<a<<endl;
    system("pause");
    return 0;
}[/mw_shl_code]

Sheldon

rosynirvana 发表于 2014-12-5 20:48
如果你是要求精确值，那内置的数据类型放不下，要自己写

那1一直乘到10呢？

Sheldon

981013 发表于 2014-12-5 20:24
[mw_shl_code=c,true]#include
#include
int main()

r*=a 是什么意思？

981013

Sheldon 发表于 2014-12-6 10:28
r*=a 是什么意思？

就是r=r*a（先计算r*a,再重新赋值给r）

Sheldon

"double","%lf","%g"都是什么意思？