课后自主练习（高精度）1080. i-1 进制 naive《编程思维与实践》个人学习笔记

最新推荐文章于 2024-07-19 22:36:19 发布
最新推荐文章于 2024-07-19 22:36:19 发布
阅读量196 收藏
点赞数
分类专栏： 编程思维与实践 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JamSlade/article/details/115870079
版权

前面的题目加了个高精度。。。写个类完事

然而本地AC OJ WA，把重载的==改成普通函数也不行。。那我只能装作自已AC了。思路是没问题的
重新写一遍发现第一次不能判断 0 -1 1的情况，第二次写发现特别大的数据出问题了。。。。吐血，日后再重新写类吧

代码一

#include<iostream>
#include<cstring>
using namespace std;
const int N = 2e4;
typedef long long ll;

string alpha = "0123456789ABCDEF";
pair<int,int> complex[16] = 
{
    {0,0},{1,0},{-1,1},{0,1},
    {0,-2},{1,-2},{-1,-1},{0,-1},
    {2,2},{3,2},{1,3},{2,3},
    {2,0},{3,0},{1,1},{2,1}
};

#include<iostream>
#include<cctype>
#include<cstring>
using namespace std;

const int MAXN = 1000;

class big
{
public:
    int dig[MAXN];
    int sign;
    int LEN;
    
//public:
    

    big();
    big(string s);
    big(const char *c);
    big(long long a);

    big &operator=(const big& b);
    big operator+(big b);
    big operator*(big b);
    big operator+=(big b);

    bool operator==(int a);
    

    void out();
    void carry();
    void test();


    bool com(ll a);

};//

void big::test()
{
    cout << sign << " " << LEN << endl;
    out();cout << endl;

}
void big::out()
{
    int l = MAXN - 1;
    while(dig[l] == 0 && l > 0)//注意0的情况
        l--;
    cout << ((sign == 1) ? "" : "-");
    for(;l >= 0; l--)
        cout << dig[l];
    //cout <<endl;
}
void big::carry()
{
    bool flag = 0;

    for(int i = 0; i < this->LEN; i++)
    {
        if(this->dig[i] >= 10)
        {
            this->dig[i + 1] += this->dig[i] / 10;
            this->dig[i] %= 10;
            if(i == LEN - 1)
                LEN++; 
        }
        else if(this->dig[i] < 0)
        {
            while(this->dig[i] < 0)
            {
                this->dig[i + 1]--;
                this->dig[i] += 10;
            }
            flag = 1;
        }
    }
    if(flag)
    {
        while(dig[LEN - 1] == 0 && LEN - 1 >= 0)
            LEN--;
        if(LEN == 0)
            LEN = 1;
    }
    

}//

big::big()
{
    LEN = 1;
    sign = 1;
    memset(dig,0,sizeof(dig));
}
big::big(string s)
{
    memset(dig,0,sizeof(dig));
    LEN = 0;
    int len = s.length();
    for(int i = len - 1; i >= 0; i--)
    {
        switch(s[i])
        {
            case '+':
            sign = 1;break;
            case '-':
            sign = -1;break;
            default:
            dig[LEN++] = s[i] - '0';
            break;
        }
    }
    if(sign != -1)sign = 1;
}
big::big(long long a)
{
    memset(dig,0,sizeof(dig));
    LEN = 0;
    sign = ((a >= 0) ? 1 : -1);

    if(a < 0)
        a = -a;

    while(a)
    {
        dig[LEN++] = a % 10;
        a /= 10;
    }
    if(sign != -1)sign = 1;
}
big::big(const char *c)
{
    memset(dig,0,sizeof(dig));
    LEN = 0;
    int len = strlen(c);
    for(int i = len - 1; i >= 0; i--)
    {
        switch(c[i])
        {
            case '+':
            sign = 1;break;
            case '-':
            sign = -1;break;
            default:
            dig[LEN++] = c[i] - '0';
        }
    }
    if(sign != -1)sign = 1;
}

big& big::operator=(const big & b)
{
    this->sign = b.sign;
    this->LEN = b.LEN;
    for(int i = 0; i < LEN;i++) 
    {
        this->dig[i] = b.dig[i];
    }
    return *this;
}
big big::operator+(big b)
{
    
    if(this->sign * b.sign == -1)
    {
        if(b.LEN > this->LEN)
        {
            for(int i = 0; i < b.LEN; i++)
                b.dig[i] -= this->dig[i];
            b.carry();
            return b;
        }
        else if(b.LEN < this->LEN)
        {
            for(int i = 0; i < this->LEN; i++)
                this->dig[i] -= b.dig[i];
            this->carry();
            return *this;
        }
        else
        {
            bool flag = true;
            for(int i = b.LEN - 1; i >= 0; i--)
            {
                if(this->dig[i] > b.dig[i])
                {flag = true;break;}
                else if(this->dig[i] < b.dig[i])
                {flag = false;break;}
            }

            if(flag)
            {
                for(int i = 0; i < this->LEN; i++)
                    this->dig[i] -= b.dig[i];
                this->carry();
                return *this;
            }
            else
            {
                for(int i = 0; i < b.LEN; i++)
                    b.dig[i] -= this->dig[i];
                b.carry();
                return b;
            }
        }
    }
    else
    {   
        int mlen = ((this->LEN > b.LEN) ? this->LEN : b.LEN);
        for(int i = 0; i < mlen; i++)
            this->dig[i] += b.dig[i];
        this->carry();
    }
    return *this;
}
big big::operator*(big b)
{
    big B;
    B.sign = this->sign * b.sign;
    for(int i = 0; i < b.LEN; i++)
    {
        for(int j = 0; j < this->LEN; j++)
        {
            B.dig[i + j] += this->dig[j] * b.dig[i];
            B.LEN = i + j + 1;//注意长度
            B.carry();
        }
    }
    return B;
}

bool big::operator==(int a)
{
    if(a * sign < 0)
        return false;
    if(a < 0)
        a = -a;


    int alen = 0;
    int dlen = MAXN;
    while(dig[dlen - 1] == 0 && dlen - 1 >= 0)
        dlen--;
    if(dlen == 0)
        dlen++;
    int temp = a;
    if(temp == 0)
        alen = 1;
    while(temp)
    {
        alen++;
        temp/=10;
    }

    if(dlen != alen)
        return false;

    temp = 0;
    for(int i = 0; i < alen; i++)
    {
        if(a % 10 != dig[i])
            return false;
        a/=10;
        temp++;
    }   
    return true;
}

void out(big R, big I)
{
    if(R==0)
    {
        if(I==0)
            cout << "0";
        else if(I==1)
            cout << "i";
        else if(I==-1)
            cout << "-i";
        else
        {
            I.out();
            cout << 'i';
        }
    }
    else
    {
        R.out();
        if(I==0){}
        else if(I==1)
            cout << "+i";
        else if(I==-1)
            cout << "-i";
        else
        {
            cout << ((I.sign == 1) ? "+" : "");
            I.out();
            cout << 'i';
        }
    }
    
    
}


int main()
{
    string s;
    cin >> s;
    int len = s.length();

    big R(complex[alpha.find(s[2])].first);
    big I(complex[alpha.find(s[2])].second);

    for(int i = 3; i < len; i++)
    {
        R = R * -4;
        I = I * -4;
        R = R + complex[alpha.find(s[i])].first;
        I = I +complex[alpha.find(s[i])].second;
    }
    out(R,I);
}

类二

#include<iostream>
#include<cctype>
#include<cstring>

typedef long long ll;
const int N = 300;
using namespace std;

struct bigint
{
    ll arr[N];
    int sign;

    bigint(ll a)
    {
        memset(arr,0,sizeof(arr));
        if(a == 0)
            sign = 0;
        else if(a < 0)
        {
            sign = -1;
            a = -a;
        }
        else
            sign = 1;
        int len = 0;
        while(a)
        {
            arr[len++] = a % 10;
            a /= 10;
        }
    }
    bigint(string s)
    {
        memset(arr,0,sizeof(arr));
        int len = 0;
        int l = s.length();

        if(s[0] == '-')
            sign = -1;
        else if(s[0] == '0')
            sign = 0;
        else
            sign = 1;

        for(int i = l - 1; i >= 0; i--)
        {
            if(s[i] == '-')
                sign = -1;
            else
            {
                arr[len++] = s[i] - '0';
            }
        }
    }
    bigint(const bigint & b)
    {
        memset(arr,0,sizeof(arr));
        sign = b.sign;
        for(int i = 0; i < N ;i ++)
            arr[i] = b.arr[i];
    }

    bool big(const bigint & b)const
    {
        if(sign > b.sign)
            return true;
        else if(sign < b.sign)
            return false;
        else 
        {
            if(sign == 1)
            {
                for(int i = N - 1; i >= 0; i--)
                {
                    if(arr[i] > b.arr[i])
                        return true;
                    else if(arr[i] < b.arr[i])
                        return false;
                }
                
                return false;
            }
            else if (sign == -1)
            {
                for(int i = N - 1; i >= 0; i--)
                {
                    if(arr[i] < b.arr[i])
                        return true;
                    else if(arr[i] > b.arr[i])
                        return false;
                }
                return false;
            }
            
        }
    }
    bool ABSbig(const bigint & b)const
    {
        for(int i = N - 1; i >= 0; i--)
        {
            if(arr[i] > b.arr[i])
                return true;
            else if(arr[i] < b.arr[i])
                return false;
        }
        
        return false;
    }
    bool small(const bigint & b)const
    {
        if(sign > b.sign)
            return false;
        else if(sign < b.sign)
            return true;
        else 
        {
            if(sign == 1)
            {
                for(int i = N - 1; i >= 0; i--)
                {
                    if(arr[i] > b.arr[i])
                        return false;
                    else if(arr[i] < b.arr[i])
                        return true;
                }
                
                return false;
            }
            else if (sign == -1)
            {
                for(int i = N - 1; i >= 0; i--)
                {
                    if(arr[i] < b.arr[i])
                        return false;
                    else if(arr[i] > b.arr[i])
                        return true;
                }
                return false;
            }
            
        }
    }
    bool ABSsmall(const bigint & b)const
    {
        for(int i = N - 1; i >= 0; i--)
        {
            if(arr[i] > b.arr[i])
                return false;
            else if(arr[i] < b.arr[i])
                return true;
        }
        return false;
    }

    bigint operator+(const bigint & b)
    {
        bigint t(*this);
        if(sign * b.sign > 0)
        {
            for(int i = 0; i < N; i++)
                t.arr[i] += b.arr[i];
        }
        else if(sign == 0)
            return b;
        else if(b.sign == 0)
            return t;
        else if(ABSbig(b))
        {
            t.sign = sign;
            for(int i = 0; i < N; i++)
                t.arr[i] = arr[i]-b.arr[i];
        }
        else if(ABSsmall(b))
        {
            t.sign = -sign;
            for(int i = 0; i < N; i++)
                t.arr[i] = b.arr[i] - arr[i];
        }
        else
        {
            memset(t.arr,0,sizeof(t.arr));
        }
        t.carry();
        return t;
    }
    bigint operator*(const bigint & b)
    {
        bigint t(*this);
        memset(t.arr,0,sizeof(t.arr));
        t.sign = sign * b.sign;
        for(int i = 0; i < N - 1; i++)
        {
            for(int j = 0; j + i < N - 1; j++)
            {
                t.arr[i+j] += arr[i] * b.arr[j];
            }
            t.carry();
        }
            

        t.carry();
        return t;
    }
    bigint& operator=(const bigint &b)
    {
        
        for(int i = 0; i < N; i++)
            arr[i] = b.arr[i];
        sign = b.sign;
        return *this;
    }

    void carry()
    {
        for(int i = 0; i < N; i++)
        {
            if(arr[i] < 0)
            {
                while(arr[i] < 0)
                {
                    arr[i + 1] -= 1;
                    arr[i] += 10;
                }
            }
            else if(arr[i] >= 10)
            {
                arr[i + 1] += arr[i] / 10;
                arr[i] %= 10;
            }
        }
    }
    void print()
    {
        cout << ((sign == -1)?"-":"");
        int l = N -1;
        while(arr[l] == 0 && l > 0)
            l--;
        
        while(l >= 0)
            cout << arr[l--]; 
    }
};

string alpha = "0123456789ABCDEF";
pair<int,int> complex[16] = 
{
    {0,0},{1,0},{-1,1},{0,1},
    {0,-2},{1,-2},{-1,-1},{0,-1},
    {2,2},{3,2},{1,3},{2,3},
    {2,0},{3,0},{1,1},{2,1}
};

int main()
{
    bigint b(10);
   

    string s;
    cin >> s;
    int len = s.length();

    bigint R(complex[alpha.find(s[2])].first);
    bigint I(complex[alpha.find(s[2])].second);

    for(int i = 3; i < len; i++)
    {
        bigint base(-4);
        R = base * R;
        I = base * I;
        bigint _1(complex[alpha.find(s[i])].first);
        R = R + _1;
        bigint _2(complex[alpha.find(s[i])].second);
        I = I + _2;
    }
    

    if(!R.small(0) && !R.big(0))//实数是零
    {
        if(!I.small(0) && !I.big(0))
            cout << '0' ;
        else if(!I.small(1) && !I.big(1))
            cout << "i";
        else if(!I.small(-1) && !I.big(-1))
            cout << "-i";
        else
        {
            I.print();cout << 'i';
        }
    }
    else
    {
        R.print();
        if(!I.small(0) && !I.big(0)){}
        else if(!I.small(1) && !I.big(1))
            cout << "+i";
        else if(!I.small(-1) && !I.big(-1))
            cout << "-i";
        else
        {   
            cout << ((I.sign == 1) ? "+" : "");
            I.print();cout << 'i';
        }
    }
}
JamSlade
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
S.I.R - SModcast互联网广播「S.I.R - SModcast Internet Radio」-crx插件
03-13
非官方的Chrome扩展程序，用于收听Kevin Smith的SModcast Internet Radio，S.I.R. 说明用于SIR的非官方Chrome扩展程序-SModcast Internet广播流！ 直接从您最喜欢的浏览器Google Chrome浏览器轻松播放/暂停Kevin ...
Node.js-适用于Node.js的用于文本学习的朴素贝叶斯算法库
08-10
Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境，它让开发者能够在服务器端使用 JavaScript 进行编程，极大地推动了全栈开发的流行。在 Node.js 中，有许多优秀的库支持各种任务，其中之一就是针对文本...
i-1进制——Roj_1014
Rachelhello123的博客
04-08 425
思考过程 这道题刚开始搞得时候，毫无头绪，因为一直把a+bi看成了一个整体，没有想着把a和b分开运算，然后思维上的难度就比较大。然后某大佬给了示范 （刚开始我还没有想到用&1的办法搞成二进制，我刚开始是直接想用16进制硬刚，有几次就算i-1的多少次方，现在想起来真的好麻烦，而且过于复杂 题目难点： 1.将16进制数转化成二进制。16进制的一位对应2进制中的四位然后将答案存在数组中，一位一位进行调用。（本来大佬给了一种比较简单的方法可以直接把16进制数搞成十进制数cin<<hex<
《编程思维与实践》1010.i-1进制I
boxueyuki的博客
03-24 156
将输入的十六进制数转化成二进制(利用字符串处理),注意到abikn​−1inkn−1​−1in−1...k0​, 故也考虑用迭代处理.pn​qn​i−1i⋅pn−1​qn−1​irn−1​rn−1​−pn−1​qn−1​pn−1​−qn−1​ipn​rn−1​−pn−1​qn−1​p0​0r0​k。
课后自主练习 （进制）1017. -1+i 进制 naive《编程思维与实践》个人学习笔记
JamSlade的博客
03-10 392
标题 题干参考1014. i-1 进制（Easy） 只不过这里是从十进制转变成 i-1进制了 思路 ①传输数据 该题目由于输入的数据含两个部分，所以要考虑 a 是否有整数 b 整数的正负性 c 是否有虚数 d 虚数的正负性 所以要多考虑考虑有没有把所有的情况都包含在里面 ②取余数转化 由于这个题只需要转化i-1进制，所以在设置com的类的时候我只进行了特殊化处理，即 但是注意的是，当余数取得1的时候，我们需要把实数R部分先-1并且把让余数=1储存起来，再进行相除，否则由于int类型/2会导致数据1的缺失
课后自主练习 （进制）1014. i-1 进制（Easy）naive《编程思维与实践》个人学习笔记
JamSlade的博客
03-09 377
题目 思路①（比较拉跨的思路） 先转换成十进制再转换成2进制之后按复数相乘若干次相加即可。可惜不能AC只能过部分数据。 麻了……题目给的数据太大LL都放不下，过段时间再写一个用字符串处理的情况吧，，，在这个事件上解题太久了，等完全AC再补充其他思路吧 代码 #include<iostream> #include<stack> using namespace std; string alpha = "0123456789ABCDEF"; void transI(stack&l
i&=i-1
I have a adream
06-21 1944
i&=i-1:消除i最右边的1 例如: i 的2进制表示为：101001000   则 i-1 的2进制表示为:101000111          i&= i-1 结果为： 101000000 所以，i&=i-1的作用为消除i最右边的1 i&=i-1 这种写法出现在 Fenwick tree 那么 i&=-i 的作用为只保留最右边的1 (i&(
scikit-learn学习笔记.pdf
06-06
Scikit-learn是Python编程语言中的一个强大机器学习库，被广泛用于数据挖掘、数据分析以及机器学习项目。这个库提供了一系列高效且易于使用的工具，帮助数据科学家进行预处理、建模、评估等任务。 **主要特点：** 1...
Python毕业设计-基于机器学习的商品评论情感分析源码+全部数据（个人高分项目）.zip
05-14
模型训练：选择合适的机器学习模型进行训练，常用的包括朴素贝叶斯（Naive Bayes）、支持向量机（Support Vector Machine）、逻辑回归（Logistic Regression）、决策树（Decision Tree）、随机森林（Random Forest）...
S.I.R - SModcast Internet Radio-crx插件
04-02
语言:English 非官方的Chrome扩展程序，用于收听Kevin Smith的SModcast网络广播，SIR 说明用于SIR的非官方Chrome扩展...促销图像中的麦克风图标归因创用CC –归因（CC BY 3.0）由Noun Project的Diego Naive设计的麦克风
【18】输出字符菱形
2301_78786609的博客
07-19 183
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Held-Karp算法的C++代码
m0_61862494的博客
07-19 94
Held-Karp算法是动态规划的一种应用，用于解决旅行商问题 (TSP)。该算法通过记录部分路径的最小成本来避免重复计算，从而有效地降低计算复杂度。Held-Karp算法使用一个状态压缩动态规划表。表示从起点出发，访问过所有由。表示的集合中的节点，并以节点。结束的最小路径长度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 157
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
树与二叉树
2201_76027754的博客
07-15 790
树和二叉树
2024.7.19 刷题总结
最新发布
TheJustice_的博客
07-19 119
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 128
完全二叉树的节点个数-递归
【算法】算法模板
qq_44765647的博客
07-19 148
LeetCode网站中学习算法的过程中使用到并总结的算法模板算法模板 数组算法模板，字符串算法模板，列表算法模板，数学算法模板，树算法模板，图算法模板，动态规划算法模板
力扣第十八题——四数之和
m0_74932528的博客
07-19 290
该代码通过排序、剪枝和双指针法，有效地解决了四数之和问题，时间复杂度从暴力解法的 O(n^4) 降低到 O(n^3)。
C语言习题~day32
TU^的博客
07-19 133
第一次循环，i 从 7 减 3 变为 4，j 加 1 变为 1；第二次循环，i 变为 1，j 变为 2；第三次循环，i 变为 253（7 减 3 溢出后变为 253），j 加 1 变为 3；第四次循环，i 变为 250，j 加 1 变为 4；第五次循环，i 变为 247，j 加 1 变为 5；依次类推，直到 i 变为 0 时，循环结束。从 7 开始每次减 3，7、4、1、253、250、247……输入：[9,6,4,2,3,5,7,0,1]无符号字符型的取值范围是 0 到 255。输入：[3,0,1]
基于sklearn.naive-bayes模块和乳腺癌数据集，编写代码训练一个朴素贝叶斯模型并进行预测
04-23
from sklearn.naive_bayes import GaussianNB from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score # 加载数据集 cancer_data = load_breast_cancer() # 定义特征...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值