长手乘法 [英] Long hand multiplication

问题描述

如果我将两个数字相乘，我希望在C ++/C程序上有这种类型的输出??


827395
x 26153
-----------
2482185
4136975
827395
4964370
1654790
-----------
21638861435

请帮帮我吗?

解决方案

您将不得不创建源代码，该源代码需要手动计算每个项目，就像您手动进行的那样.
如果我们使用您的示例，则必须计算所需的正手行数，然后为每行计算.第一手的简单行是827395 x 3，第二行是827395 x 5由一列偏移，依此类推.通过类似c ++的解决方案编写代码.但是我怕没有完美的解决方案.

CNumber.h的内容:

 #ifndef__CNUMBER_H
 #define__CNUMBER_H

// < span class ="code-keyword">此:CNumber.h</span> 
// 示例:CNumber.cpp 

#include   <  > 

模板< class TI>  const  TI& myminimum( const  TI& a， const  TI& b){ return  a< b?a:b; }
模板< class TI>  const  TI& mymaximum( const  TI& a， const  TI& b){ return  a< b?b:a; }

课程 bNumber
{
公共:
bNumber();
〜bNumber();

受保护的:
 void  d( const   unsigned   int  n);
无效 t( const   unsigned   int  n);

受保护的:
未签名  int  _ndigits；
未签名 字符 * _adigits；
TCHAR * _tmpout;

};

类 CNumber:bNumber
{
公共:
CNumber();
CNumber(CNumber& n);
CNumber( const   unsigned   int  z)；
CNumber( const  TCHAR * s);
〜CNumber();

运算符 运算符 TCHAR *();

CNumber& 运算符 =(CNumber& n);
CNumber& 运算符 ==( const  TCHAR *)；
CNumber& 运算符 ==((span class ="code-keyword"> const   unsigned   int  z)；

CNumber 运算符 * =(( const   unsigned  字符； m);
CNumber& 运算符 + =(CNumber& add);

CNumber 运算符 *((span class ="code-keyword"> const   unsigned  字符; m);
CNumber 运算符 *(CNumber& mul);

CNumber& exp(未签名  int  e)；

未签名 字符 运算符 []( const   unsigned   int  ix);

未签名  int  length();
 const  TCHAR * pad( const  未签名  int  n， const  TCHAR c)；

私有:
内联
未签名  int  m10( unsigned   int  d，未签名 char& c){c = d％10; 返回 d/10； }
 void .trim();
};


#endif//__ CNUMBER_H  

CNumber.cpp的内容:

 #include   "  CNumber.h"

/// ////////////////////////////
 //  bNumber 
bNumber :: bNumber()
{
_ndigits ==  0 ;
_adigits ==  0 ;
_tmpout =  0 ;
}

bNumber ::〜bNumber()
{
如果(_ adigits)删除 [] _ adigits；
如果(_ tmpout)删除 [] _ tmpout；
}

 void  bNumber :: d( const  未签名  int  n)
{
未签名 字符 * p == 新 未签名 字符 [n];
未签名  int  i，m;
如果(_ adigits)
{
 for (i =  0 ，m = myminimum(n，_ndigits); i< m; i ++)p [i] = _ adigits [i];
删除 [] _ adigits；
}
_adigits = p;
}

无效 bNumber :: t( const  未签名  int  n)
{
TCHAR * p == 新 TCHAR [n];
如果(_ tmpout)删除 [] _ tmpout；
_tmpout = p;
}

/// ////////////////////////////
 //  CNumber 
CNumber :: CNumber()
{
}

CNumber :: CNumber(CNumber& n)
{
运算符 =(n);
}

CNumber :: CNumber( const   unsigned   int  z)
{
运算符 =(z);
}

CNumber :: CNumber( const  TCHAR *
{
运算符 ==(s);
}

CNumber ::〜CNumber()
{
}

CNumber :: 运算符  const  TCHAR *()
{
返回垫( 0 ，' ');
}

CNumber& CNumber :: 运算符 =(CNumber& n)
{
未签名  int  i;
d(_ndigits = n._ndigits);
 for (i =  0 ; i< _ndigits; i ++)_adigits [i] = n._adigits [i ];
返回 ** 此；
}

CNumber& CNumber :: 运算符 ==( const  TCHAR *
{
未签名  int  i，n = _tcslen(s);
d(_ndigits = n);
 (i =  0 ; i< n; i ++)_adigits [i] == s [i]- '  0';
返回 ** 此；
}

CNumber& CNumber :: 运算符 ==((span class ="code-keyword"> const   unsigned   int  z)
{
未签名  int  i，r = z;
d(_ndigits =  10 );
 (i =  0 ; i< 10; i ++){_adigits [ 10 ; }
返回 ** 此；
}

CNumber CNumber :: 运算符 *((span class ="code-keyword"> const   unsigned  字符 m)
{
返回 CNumber(* 此)* = m；
}

CNumber CNumber :: 运算符 * =(( const   unsigned  字符 m)
{
未签名  int  i，r =  0 ;
d(++ _ ndigits);
 for (i = _ndigits-  1 ; i; i--)
{
r + =(未签名 < int )m *(( int )m /span>  int )_ adigits [i-  1 ];
r = m10(r，_adigits [i]);
}
_adigits [i] =(( unsigned  < char )r；
修剪();
返回 ** 此；
}

CNumber& CNumber :: 运算符 + =(CNumber& add)
{
未签名  int  i，n，r;

n = mymaximum(_ndigits，add._ndigits);
d(1 + n);
 for (r = i =  0 ; i< n; i ++)
{
r + = 运算符 [](i)+ add [i];
r = m10(r，_adigits [n-i]);
}
 for (; i< _ndigits; i ++)
{
r + = 运算符 [](i);
r = m10(r，_adigits [n-i]);
}
 for (; i< add._ndigits; i ++)
{
r + = add [i];
r = m10(r，_adigits [n-i]);
}

_adigits [ 0 ] = r;
_ndigits ==  1  + n;
修剪();

返回 ** 此；
}

CNumber CNumber :: 运算符 *(CNumber& mul)
{
CNumber n，m;
未签名  int  i;
 for (i =  0 ; i< mul.length(); i ++)
{
m =((*  this )* mul [i];
m.exp(i);
n + = m;
}
返回 n；
}

未签名 字符 CNumber :: 运算符 [] (常量 无符号  int  ix)
{
返回 ix ix__ndigits?_adigits [_ndigits-ix-  1 ]: unsigned  < int  e)
{
如果(_ ndigits)
{
d(e + = _ ndigits);
 for (; _ ndigits< e; _ndigits ++)_adigits [_ndigits] =  0 ;
}
返回 ** 此；
}

未签名  int  CNumber :: length()
{
返回 _ndigits；
}

 const  TCHAR * CNumber :: pad( const   unsigned   int  n， const  TCHAR c)
{
未签名  int  i，o，x;

 for (i =  0 ;(i< _ndigits)&&( for (o =  0 ; o<(x-(_ ndigits-i)); o ++)_tmpout [ o] = c;
 (; i< _ndigits; i ++)_tmpout [o ++] == '  0 ;

返回 _tmpout;
}

// < span class ="code-keyword"> private</span> 
无效 CNumber :: trim()
{
未签名  int  i，o;
 for (i =  0 ;(i< _ndigits)&&(如果(i)
{
 for (o =  0 ; i< _ndigits; i ++)_adigits [o ++] = _ adigits [i];
_ndigits = o;
}
} 

main.cpp的内容:

 #pragma一次
 #include   <   stdio.h  > 
 #include   " 

 int  _tmain( int  argc，_TCHAR * argv [])
{
{
枚举 {́PAD ==  40 ，}};

CNumber a = _T(" );
CNumber b == _ T(" );
CNumber c;
未签名  int  i;

如果(1< argc)a = argv [ 1 ];
如果(2< argc)b = argv [ 2 ];

_tprintf(__ T(" )，( const  TCHAR *)a，( const  TCHAR *)b);
_tprintf(__ T(" ))；

 for (i =  0 ; i< b.length(); i ++)
{
c = a * b [i];
c.exp(i);
如果(c.length())__ tprintf(__ T(" ％s \ r \ n")，c.pad(PAD，'' ))；
}

_tprintf(__ T(" ))；
c = a * b;
_tprintf(__ T(" )，c.pad(PAD，' '));
_tprintf(__ T(" ))；

_gettch();
}
返回  0 ；
} 

最好的问候 Emilio Garavaglia 的有用提示.

I want this type of output on C++/C Program if I multiply 2 numbers??


827395
x 26153
-----------
2482185
4136975
827395
4964370
1654790
-----------
21638861435

Please help me out?

解决方案

You would have to create source that takes calculates each item manually as though you were doing it by hand.
If we use your example, you would have to calculate how many rows of longhand you require and then calculate for each of the rows. The first longhand row is simply 827395 x 3, the second is 827395 x 5 offset by one column, etc.

In honor to Emilio Garavaglia ive replaced the original code by a more c++ like solution. But im afraid there is no perfect solution.

content of CNumber.h:

#ifndef __CNUMBER_H
#define __CNUMBER_H

// <span class="code-keyword">this: CNumber.h</span>
// impl: CNumber.cpp

#include <tchar.h>

template <class TI> const TI& myminimum(const TI& a,const TI& b){ return a<b?a:b; }
template <class TI> const TI& mymaximum(const TI& a,const TI& b){ return a<b?b:a; }

class bNumber
{
public:
  bNumber();
  ~bNumber();

protected:
  void            d(const unsigned int n);
  void            t(const unsigned int n);

protected:
  unsigned int    _ndigits;
  unsigned char*  _adigits;
  TCHAR*          _tmpout;

};

class CNumber : bNumber
{
public:
  CNumber();
  CNumber(CNumber& n);
  CNumber(const unsigned int z);
  CNumber(const TCHAR* s);
  ~CNumber();
  
  operator const TCHAR*  ();

  CNumber&  operator = (CNumber& n);
  CNumber&  operator = (const TCHAR* s);
  CNumber&  operator = (const unsigned int z);

  CNumber    operator *= (const unsigned char m);
  CNumber&  operator += (CNumber& add);

  CNumber    operator * (const unsigned char m);
  CNumber    operator * (CNumber& mul);

  CNumber&      exp(unsigned int e);

  unsigned char  operator [] (const unsigned int ix);

  unsigned int  length();
  const TCHAR*  pad(const unsigned int n,const TCHAR c);

private:
  inline
  unsigned int    m10(unsigned int d,unsigned char& c){ c=d%10; return d/10; }
  void            trim();
};


#endif // __CNUMBER_H

content of CNumber.cpp:

#include "CNumber.h"

////////////////////////////////
// bNumber
bNumber::bNumber()
{
  _ndigits = 0;
  _adigits = 0;
  _tmpout  = 0;
}

bNumber::~bNumber()
{
  if(_adigits) delete [] _adigits;
  if(_tmpout) delete [] _tmpout;
}

void bNumber::d(const unsigned int n)
{
  unsigned char*  p = new unsigned char[n];
  unsigned int    i,m;
  if(_adigits)
  {
    for(i=0,m=myminimum(n,_ndigits);i<m;i++) p[i] = _adigits[i];
    delete [] _adigits;
  }
  _adigits = p;
}

void bNumber::t(const unsigned int n)
{
  TCHAR*  p = new TCHAR[n];
  if(_tmpout) delete [] _tmpout;
  _tmpout = p;
}

////////////////////////////////
// CNumber
CNumber::CNumber()
{
}

CNumber::CNumber(CNumber& n)
{
  operator = (n);
}

CNumber::CNumber(const unsigned int z)
{
  operator = (z);
}

CNumber::CNumber(const TCHAR* s)
{
  operator = (s);
}

CNumber::~CNumber()
{
}

CNumber::operator const TCHAR*  ()
{
  return pad(0,' ');
}

CNumber& CNumber::operator = (CNumber& n)
{
  unsigned int  i;
  d(_ndigits=n._ndigits);
  for(i=0;i<_ndigits;i++) _adigits[i] = n._adigits[i];
  return *this;
}

CNumber& CNumber::operator = (const TCHAR* s)
{
  unsigned int i,n = _tcslen(s);
  d(_ndigits=n);
  for(i=0;i<n;i++) _adigits[i] = s[i]-'0';
  return *this;
}

CNumber& CNumber::operator = (const unsigned int z)
{
  unsigned int i,r = z;
  d(_ndigits=10);
  for(i=0;i<10;i++){ _adigits[9-i]=r%10; r/=10; }
  return *this;
}

CNumber CNumber::operator * (const unsigned char m)
{
  return CNumber(*this) *= m;
}

CNumber CNumber::operator *= (const unsigned char m)
{
  unsigned int  i,r=0;
  d(++_ndigits);
  for(i=_ndigits-1;i;i--)
  {
    r += (unsigned int)m * (unsigned int)_adigits[i-1];
    r = m10(r,_adigits[i]);
  }
  _adigits[i] = (unsigned char)r;
  trim();
  return *this;
}

CNumber& CNumber::operator += (CNumber& add)
{
  unsigned int  i,n,r;

  n = mymaximum(_ndigits,add._ndigits);
  d(1+n);
  for(r=i=0;i<n;i++)
  {
    r += operator[](i) + add[i];
    r = m10(r,_adigits[n-i]);
  }
  for(;i<_ndigits;i++)
  {
    r += operator[](i);
    r = m10(r,_adigits[n-i]);
  }
  for(;i<add._ndigits;i++)
  {
    r += add[i];
    r = m10(r,_adigits[n-i]);
  }

  _adigits[0] = r;
  _ndigits = 1 + n;
  trim();

  return *this;
}

CNumber CNumber::operator * (CNumber& mul)
{
  CNumber        n,m;
  unsigned int  i;
  for(i=0;i<mul.length();i++)
  {
    m = (*this) * mul[i];
    m.exp(i);
    n += m;
  }
  return n;
}

unsigned char CNumber::operator [] (const unsigned int ix)
{
  return ix<_ndigits?_adigits[_ndigits-ix-1]:0;
}

CNumber& CNumber::exp(unsigned int e)
{
  if(_ndigits)
  {
    d(e+=_ndigits);
    for(;_ndigits<e;_ndigits++) _adigits[_ndigits]=0;
  }
  return *this;
}

unsigned int CNumber::length()
{
  return _ndigits;
}

const TCHAR* CNumber::pad(const unsigned int n,const TCHAR c)
{
  unsigned int i,o,x;

  for(i=0;(i<_ndigits)&&(0==_adigits[i]);i++);
  x = mymaximum(n,_ndigits-i); t(1+x);
  for(o=0;o<(x-(_ndigits-i));o++) _tmpout[o] = c;
  for(;i<_ndigits;i++) _tmpout[o++] = '0' + _adigits[i];
  _tmpout[o] = 0;

  return _tmpout;
}

// <span class="code-keyword">private</span>
void CNumber::trim()
{
  unsigned int  i,o;
  for(i=0;(i<_ndigits)&&(0==_adigits[i]);i++);
  if(i)
  {
    for(o=0;i<_ndigits;i++) _adigits[o++]=_adigits[i];
    _ndigits = o;
  }
}

content of main.cpp:

#pragma once
#include <stdio.h>
#include "CNumber.h"

int _tmain(int argc, _TCHAR* argv[])
{
  {
    enum{ PAD = 40, };

    CNumber        a = _T("905427184367094827395");
    CNumber        b = _T("4838203673416526153");
    CNumber        c;
    unsigned int  i;

    if(1<argc) a = argv[1];
    if(2<argc) b = argv[2];

    _tprintf(__T("%s x %s = \r\n"),(const TCHAR*)a,(const TCHAR*)b);
    _tprintf(__T("-----------------------------\r\n"));

    for(i=0;i<b.length();i++)
    {
      c = a * b[i];
      c.exp(i);
      if(c.length()) _tprintf(__T("%s\r\n"),c.pad(PAD,' '));
    }

    _tprintf(__T("-----------------------------\r\n"));
    c = a * b;
    _tprintf(__T("%s\r\n"),c.pad(PAD,' '));
    _tprintf(__T("=============================\r\n"));

    _gettch();
  }
  return 0;
}

Best regards to the useful hints of Emilio Garavaglia.

这篇关于长手乘法的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！