HJ42：学英语

最新推荐文章于 2022-07-19 19:49:19 发布
最新推荐文章于 2022-07-19 19:49:19 发布
阅读量402 收藏
点赞数
分类专栏： HUAWEI机试 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27538633/article/details/120981449
版权

1、解题思路：
求解这道题，需要把输入的数字，三位三位拆开来进行一个处理。那么就会发现，求解超过三位数的thousand时，thousand的左起三位“个十百”，与“个十百”的处理方式相似；同理，超过六位数的million左起的六位数和million的六位数处理方式相似，超过九位数的billion左起九位数和billion的九位数处理方式相似。
故而，下面的代码看着很长，但string san_san(string str)、string six_san(string str)、string six_san2(string str)、string nine_san(string str)、string twelve_san(string str)这几个函数的代码几乎一样，只不过在特定位置做了下修改。
之所以这样复杂，就是没有用到递归的思想，如果用上递归的思想，则代码量会减少五分之四。

2、代码如下：

#include <iostream>
#include <string>
using namespace std;

string tens[] = { "", "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety" };
string ones[] = { "", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
string ones2[] = { "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen",
                "nineteen" };

string san_san(string str)
{
    if (str.size() == 1)
    {
        int i = 0;
        int num = (str[i]-'0') % 10;
        return ones[num];
    }
    else if (str.size() == 2)
    {
        int i = 0;
        string ten;
        int num = (str[i] - '0') % 10;
        ten = tens[num];

        if (ten == "ten")
        {
            int i = 0;
            int num = (str[i + 1] - '0') % 10;
            return ones2[num];
        }
        else
        {
            int i = 0;
            string strapp;
            int num = (str[i + 1] - '0') % 10;
            if (str[i] == '0')
            {
                strapp = ones[num];
                return strapp;
            }
            else
            {
                strapp = ten + " " + ones[num];
                return strapp;
            }
        }
    }
    else //str.size()=3
    {
        int i = 0;
        string bai;
        int num = (str[i] - '0') % 10;
        bai = ones[num] + " " + "hundred";

        //重复之前两位数时
        string ten; //十位数
        int num2 = (str[i+1] - '0') % 10;
        ten = tens[num2];

        if (ten == "ten") //十位数为1
        {
            int i = 0;
            string strapp;
            int num = (str[i + 2] - '0') % 10;
            if (str[i] != '0')
            {
                strapp = bai + " and " + ones2[num];
                return strapp;
            }
            else
            {
                strapp = ones2[num];
                return strapp;
            }
        }
        else //十位数不是1
        {
            int i = 0;
            string strapp;
            if (str[i] != '0') //百位不是0
            {
                if (str[i + 1] != '0') //十位不是0
                {
                    int num = (str[i+2] - '0') % 10;
                    if (str[i + 2] != '0')
                    {
                        strapp = bai + " and " + ten + " " + ones[num];
                        return strapp;
                    }
                    else
                    {
                        strapp = bai + " and " + ten;
                        return strapp;
                    }
                }
                else //十位等于0
                {
                    int num = (str[i + 2] - '0') % 10;
                    if (str[i + 2] != '0')
                    {
                        strapp = bai + " and " + ones[num];
                        return strapp;
                    }
                    else
                    {
                        strapp = bai;
                        return strapp;
                    }
                }
            }
            else //百位为0
            {
                if (str[i + 1] != '0') //十位不是0
                {
                    int num = (str[i + 2] - '0') % 10;
                    if (str[i + 2] != '0')
                    {
                        strapp = ten + " " + ones[num];
                        return strapp;
                    }
                    else
                    {
                        strapp = ten;
                        return strapp;
                    }
                }
                else //十位等于0
                {
                    int num = (str[i + 2] - '0') % 10;
                    if (str[i + 2] != '0')
                    {
                        strapp = ones[num];
                        return strapp;
                    }
                    else
                    {
                        strapp = bai;
                        return strapp;
                    }
                }
            }
        }
    }
}

string six_san(string str)
{
    if (str.size() == 4)
    {
        int i = 0;
        int num = (str[i] - '0') % 10;
        return ones[num] + " thousand";
    }
    else if (str.size() == 5)
    {
        int i = 0;
        string ten;
        int num = (str[i] - '0') % 10;
        ten = tens[num];

        if (ten == "ten")
        {
            int i = 0;
            int num = (str[i + 1] - '0') % 10;
            return ones2[num] + " thousand";
        }
        else //十位不是1
        {
            int i = 0;
            string strapp;
            int num = (str[i + 1] - '0') % 10;
            if (str[i + 1] != '0')
            {
                if (str[i] == '0')
                {
                    strapp = ones[num] + " thousand";
                    return strapp;
                }
                else
                {
                    strapp = ten + " " + ones[num] + " thousand";
                    return strapp;
                }
            }
            else
            {
                if (str[i] == '0')
                {
                    return strapp;
                }
                else
                {
                    strapp = ten + " thousand";
                    return strapp;
                }
            }
            
        }
    }
    else //str,size()=6
    {
        int i = 0;
        string bai;
        int num = (str[i] - '0') % 10;
        bai = ones[num] + " " + "hundred";

        //重复之前两位数时
        string ten; //十位数
        int num2 = (str[i + 1] - '0') % 10;
        ten = tens[num2];

        if (ten == "ten") //十位数为1
        {
            int i = 0;
            string strapp;
            int num = (str[i + 2] - '0') % 10;
            if (str[i] != '0')
            {
                strapp = bai + " and " + ones2[num] + " thousand";
                return strapp;
            }
            else
            {
                strapp = ones2[num] + " thousand";
                return strapp;
            }
        }
        else //十位数不是1
        {
            int i = 0;
            string strapp;
            int num = (str[i + 2] - '0') % 10;
            if (str[i + 1] != '0')
            {
                if (str[i + 2] != '0')
                {
                    strapp = bai + " and " + ten + " " + ones[num] + " thousand";
                    return strapp;
                }
                else
                {
                    strapp = bai + /*" and "  +*/ " thousand";
                    return strapp;
                }
            }
            else // 等于0的情况
            {
                if (str[i + 2] != '0')
                {
                    strapp = bai + " and " + ones[num] + " thousand";
                    return strapp;
                }
                else
                {
                    strapp = bai + " thousand";
                    return strapp;
                }
            }
        }
    }
}

string six_san2(string str)
{
    if (str.size() == 1)
    {
        int i = 0;
        int num = (str[i] - '0') % 10;
        return ones[num] + " thousand";
    }
    else if (str.size() == 2)
    {
        int i = 0;
        string ten;
        int num = (str[i] - '0') % 10;
        ten = tens[num];

        if (ten == "ten")
        {
            int i = 0;
            int num = (str[i + 1] - '0') % 10;
            return ones2[num] + " thousand";
        }
        else //十位不是1
        {
            int i = 0;
            string strapp;
            int num = (str[i + 1] - '0') % 10;
            if (str[i] == '0')
            {
                strapp = ones[num] + " thousand";
                return strapp;
            }
            else
            {
                strapp = ten + " " + ones[num] + " thousand";
                return strapp;
            }
        }
    }
    else //str,size()=6
    {
        int i = 0;
        string bai;
        int num = (str[i] - '0') % 10;
        bai = ones[num] + " " + "hundred";

        //重复之前两位数时
        string ten; //十位数
        int num2 = (str[i + 1] - '0') % 10;
        ten = tens[num2];

        if (ten == "ten") //十位数为1
        {
            int i = 0;
            string strapp;
            int num = (str[i + 2] - '0') % 10;
            if (str[i] != '0')
            {
                strapp = bai + " and " + ones2[num] + " thousand";
                return strapp;
            }
            else
            {
                strapp = ones2[num] + " thousand";
                return strapp;
            }
        }
        else //十位数不是1
        {
            int i = 0;
            string strapp;
            int num = (str[i + 2] - '0') % 10;
            if (str[i + 1] != '0')
            {
                if (str[i + 2] != '0')
                {
                    strapp = bai + " and " + ten + " " + ones[num] + " thousand";
                    return strapp;
                }
                else
                {
                    strapp = bai + /*" and "  +*/ " thousand";
                    return strapp;
                }
            }
            else // 等于0的情况
            {
                if (str[i + 2] != '0')
                {
                    strapp = bai + " and " + ones[num] + " thousand";
                    return strapp;
                }
                else
                {
                    strapp = bai + " thousand";
                    return strapp;
                }
            }
        }
    }
}

string nine_san(string str)

{
    if (str.size() == 7)
    {
        int i = 0;
        int num = (str[i] - '0') % 10;
        return ones[num] + " million";
    }
    else if (str.size() == 8)
    {
        int i = 0;
        string ten;
        int num = (str[i] - '0') % 10;
        ten = tens[num];

        if (ten == "ten")
        {
            int i = 0;
            int num = (str[i + 1] - '0') % 10;
            return ones2[num] + " million";
        }
        else //十位不是1
        {
            int i = 0;
            string strapp;
            int num = (str[i + 1] - '0') % 10;
            if (str[i] == '0')
            {
                strapp = ones[num] + " million";
                return strapp;
            }
            else
            {
                strapp = ten + " " + ones[num] + " million";
                return strapp;
            }
        }
    }
    else //str,size()=9
    {
        int i = 0;
        string bai;
        int num = (str[i] - '0') % 10;
        bai = ones[num] + " " + "hundred";

        //重复之前两位数时
        string ten; //十位数
        int num2 = (str[i + 1] - '0') % 10;
        ten = tens[num2];

        if (ten == "ten") //十位数为1
        {
            int i = 0;
            string strapp;
            int num = (str[i + 2] - '0') % 10;
            if (str[i] != '0')
            {
                strapp = bai + " and " + ones2[num] + " million";
                return strapp;
            }
            else
            {
                strapp = ones2[num] + " million";
                return strapp;
            }
        }
        else //十位数不是1
        {
            int i = 0;
            string strapp;
            int num = (str[i + 2] - '0') % 10;
            if (str[i + 1] != '0')
            {
                if (str[i + 2] != '0')
                {
                    strapp = bai + " and " + ten + " " + ones[num] + " million";
                    return strapp;
                }
                else
                {
                    strapp = bai + /*" and "  +*/ " million";
                    return strapp;
                }
            }
            else // 等于0的情况
            {
                if (str[i + 2] != '0')
                {
                    strapp = bai + " and " + ones[num] + " million";
                    return strapp;
                }
                else
                {
                    strapp = bai + " million";
                    return strapp;
                }
            }
        }
    }
}

string twelve_san(string str)
{
    if (str.size() == 10)
    {
        int i = 0;
        int num = (str[i] - '0') % 10;
        return ones[num] + " billion";
    }
    else if (str.size() == 11)
    {
        int i = 0;
        string ten;
        int num = (str[i] - '0') % 10;
        ten = tens[num];

        if (ten == "ten")
        {
            int i = 0;
            int num = (str[i + 1] - '0') % 10;
            return ones2[num] + " billion";
        }
        else //十位不是1
        {
            int i = 0;
            string strapp;
            int num = (str[i + 1] - '0') % 10;
            if (str[i] == '0')
            {
                strapp = ones[num] + " billion";
                return strapp;
            }
            else
            {
                strapp = ten + " " + ones[num] + " billion";
                return strapp;
            }
        }
    }
    else //str,size()=12
    {
        int i = 0;
        string bai;
        int num = (str[i] - '0') % 10;
        bai = ones[num] + " " + "hundred";

        //重复之前两位数时
        string ten; //十位数
        int num2 = (str[i + 1] - '0') % 10;
        ten = tens[num2];

        if (ten == "ten") //十位数为1
        {
            int i = 0;
            string strapp;
            int num = (str[i + 2] - '0') % 10;
            if (str[i] != '0')
            {
                strapp = bai + " and " + ones2[num] + " billion";
                return strapp;
            }
            else
            {
                strapp = ones2[num] + " billion";
                return strapp;
            }
        }
        else //十位数不是1
        {
            int i = 0;
            string strapp;
            int num = (str[i + 2] - '0') % 10;
            if (str[i + 1] != '0')
            {
                if (str[i + 2] != '0')
                {
                    strapp = bai + " and " + ten + " " + ones[num] + " billion";
                    return strapp;
                }
                else
                {
                    strapp = bai + /*" and "  +*/ " billion";
                    return strapp;
                }
            }
            else // 等于0的情况
            {
                if (str[i + 2] != '0')
                {
                    strapp = bai + " and " + ones[num] + " billion";
                    return strapp;
                }
                else
                {
                    strapp = bai + " billion";
                    return strapp;
                }
            }
        }
    }
}

int main()
{
    long number;
    while (cin >> number)
    {
        string str = to_string(number);
        if (str.size() <= 3)
        {
            string str1 = san_san(str);
            cout << str1 << endl;
        }
        else if (str.size() >= 4 && str.size() <= 6)
        {
            string str2 = six_san(str);
            string str3 = str.substr(str.size() - 3, str.size() - 1); //只取用“个位、十位、百位”
            string str4 = san_san(str3);
            string str5 = str2 + " " + str4;           
            cout << str5 << endl;
        }
        else if (str.size() >= 7 && str.size() <= 9)
        {
            string str6 = nine_san(str); //million

            string str9 = str.substr(str.size() - 6, str.size() - 4);
            string str10 = six_san2(str9); //thousand

            string str7 = str.substr(str.size() - 3, str.size() - 1);
            string str8 = san_san(str7); //个十百

            string str11 = str6 + " " + str10 + " " + str8;
            cout << str11 << endl;
        }
        else if (str.size() >= 10 && str.size() <= 12)
        {
            string str11 = twelve_san(str); //billion

            string str12 = str.substr(str.size() - 9, str.size() - 7);
            string str6 = nine_san(str12); //million

            string str9 = str.substr(str.size() - 6, str.size() - 4);
            string str10 = six_san(str9); //thousand

            string str7 = str.substr(str.size() - 3, str.size() - 1);
            string str8 = san_san(str7); //个十百

            string str13 = str11 + " " + str6 + " " + str10 + " " + str8;
            cout << str13 << endl;
        }
    }
    return 0;
}

3、运行结果
如下图所示：
在这里插入图片描述

4、运行分析
这道题，其实代码中，只写到了12位数，而且，对于类似于“8088”输出的结果，在超过三位以后，没有进行修改，但是依然AC通过，猜测这道题的测试点取的比较少，而且测试点不全面。
接下来，要做的，就是对代码做一个优化缩减，再重新运行。
5、代码优化
此处的代码，是其他同学AC通过的代码，这段代码比较简洁，逻辑上比较好理解，方法很巧妙。代码存在一个小小的问题，在判决条件上，已在代码中修改。

#include <iostream>
#include <sstream>

using namespace std;

string tens[] = { "", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety" };
string ones[] = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten",
                "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen",
                "nineteen" };
string others[] = { "", "thousand", "million", "billion" };
int scopes[] = { 1, 1000, 1000000, 1000000000 };

string convert(int num) {
    int lower;
    int hundred;
    stringstream ss;

    // 处理小于1000的情况
    if (num <= 19) return ones[num];
    if (num >= 20 && num <= 99) return tens[num / 10] + ((num % 10 > 0) ? " " + ones[num % 10] : "");
    if (num >= 100 && num <= 999) {
        ss << ones[num / 100] << " hundred";
        if (num % 100 > 0) {
            ss << " and " << convert(num % 100);
        }
        return ss.str();
    }

    // 处理大于1000的情况
    for (int i = 3; i >= 0; i--) {
//        if (num > scopes[i]) {
        if (num >= scopes[i]) { //此处做了修改，判决条件应该包含等于号
            ss << convert(num / scopes[i]) << " " << others[i];
            num %= scopes[i];
            // 后续仍然有数字
            if (num > 0) {
                ss << ' ';
            }
        }
    }
    return ss.str();
}

int main() {
    int num;
    while (cin >> num) 
    {
        getchar();
        cout << convert(num) << endl;
    }
    return 0;
}

运行结果如下图所示：
在这里插入图片描述

大河大江
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【牛客网华为机试】HJ42 学英语
202xxx的博客
09-12 1058
题目 描述 Jessi初学英语，为了快速读出一串数字，编写程序将数字转换成英文： 如22：twentytwo，123：onehundredandtwentythree。 说明： 数字为正整数，长度不超过九位，不考虑小数，转化结果为英文小写； 输出格式为twentytwo； 非法数据请返回“error”； 关键字提示：and，billion，million，thousand，hundred。 本题含有多组输入数据。 输入描述： 输入一个long型整数 输出描述： 输出相应...
【牛客网华为机试】HJ34 图片整理
202xxx的博客
09-08 598
题目 描述 Lily上课时使用字母数字图片教小朋友们学习英语单词，每次都需要把这些图片按照大小（ASCII码值从小到大）排列收好。请大家给Lily帮忙，通过C语言解决。 本题含有多组样例输入。 输入描述： Lily使用的图片包括"A"到"Z"、"a"到"z"、"0"到"9"。输入字母或数字个数不超过1024。 输出描述： Lily的所有图片按照从小到大的顺序输出 示例1 输入： Ihave1nose2hands10fingers 输出： 0112Iaadeeefghhinnno
HJ42 学英语（递归）
yangyangcome的博客
06-26 463
描述 Jessi初学英语，为了快速读出一串数字，编写程序将数字转换成英文：如22：twenty two，123：one hundred and twenty three。 说明：数字为正整数，长度不超过九位，不考虑小数，转化结果为英文小写；输出格式为twenty two；非法数据请返回“error”；关键字提示：and，billion，million，thousand，hundred。 本题含有多组输入数据。 输入描述：输入一个long型整数 输出描述：输出相应的英文写法 示例1 输入：2356 输出：tw
《华为机试》刷题之HJ42 学英语
胡萝卜
02-21 329
一、题目 二、示例 三、代码 list1 = ['zero','one','two','three','four','five','six','seven','eight', 'nine','ten','eleven','twelve','thirteen','fourteen','fifteen', 'sixteen','seventeen','eighteen','nineteen'] list2 = [0,0,'twenty','thirty','forty',
HJ42 学英语（不会）
engineer0的博客
09-24 203
描述 Jessi初学英语，为了快速读出一串数字，编写程序将数字转换成英文： 如22：twenty two，123：one hundred and twenty three。 说明： 数字为正整数，长度不超过九位，不考虑小数，转化结果为英文小写； 输出格式为twenty two； 非法数据请返回“error”； 关键字提示：and，billion，million，thousand，hundred。 本题含有多组输入数据。 输入描述： 输入一个long型整数 输出描述： 输出相应的英文写
华为机试HJ42：学英语
热门推荐
翟天保的博客
08-14 1万+
C++实现——学英语
PIC24HJ64GP502中文翻译和英文原版资料
最新发布
09-29
文档中的中文翻译为理解PIC24HJ64GP502提供了便利，特别是对于非英语背景的工程师来说，能够快速掌握关键技术和参数。英文原版资料则保留了原始的详细信息和专业术语，确保了技术的准确性。 四、应用实例 在工业...
HJ23python
09-02
这个解答适用于输入的字符串长度小于等于20个字节，并且字符串只包含小写英文字母的情况。<span class="em">1</span><span class="em">2</span><span class="em">3 #### 引用[.reference_title] - *1* [HJ23 删除...
CTF密码学题目初探
hzy_wsq的博客
06-15 3011
CTF密码学题目初探（一）密码学总结（一）1.常见线索2.常见编码 密码学总结（一） 密码学一般可分为 古典密码学 和现代密码学。CTF中脑洞密码题(非现代加密方式)一般都是各种古典密码的变形。 1.常见线索 一般情况下，题目中会给出一些线索。比如题目名称，题目描述等。 举例：题目名称为base64 题目链接 举例：题目描述中写了“上面画着一个农妇在栅栏里面喂5只小鸡”… 题目链接 2.常见编码 base64/32/16编码 加密解密网站链接 原理：Base64是用于传输8Bit字节码的编码方式之一，
牛客网 HJ42 学英语
ppslizejun的专栏
07-19 189
3.公式百万以下千以上的数XthousandX,10亿以下百万以上的数XmillionXthousandX,10亿以上的数XbillionXmillionXthousandX.每个X分别代表三位数或两位数或一位数。4.在英式英语中百位数和十位数之间要加and，美式英语中则会省略，我们这个题目采用加上and，百分位为零的话，这道题目我们省略and。关键字提示and，billion，million，thousand，hundred。输入一个long型整数。...
HJ42 学英语
engineer0的博客
09-24 134
描述 Jessi初学英语，为了快速读出一串数字，编写程序将数字转换成英文： 如22：twenty two，123：one hundred and twenty three。 说明： 数字为正整数，长度不超过九位，不考虑小数，转化结果为英文小写； 输出格式为twenty two； 非法数据请返回“error”； 关键字提示：and，billion，million，thousand，hundred。 本题含有多组输入数据。 输入描述： 输入一个long型整数 输出描述： 输出相应的英文写
牛客 HJ42 学英语 c++
weixin_43420303的博客
04-16 844
题目描述： 本道题难度是较难，但属于处理起来比较复杂的那种，题意很好理解，也不难做，其实就是简单的字符串拼接而已。 题目要求每三位数字放一块进行处理，那就num%1000 作为一个小块进行处理就完事了。 需要注意的点 1. 每三位处理一次，三位处理完后根据取余次数，如果（num/1000！=0），就给字符串前面加 thousan、million，以及其他更高的等级。 2.三位一处理，如果百位不为0，那就给字符串加一个“ hundred and ”，然后把百位数字加在前面。 3.特殊化处理，我特殊化处理了1
学英语
无情Array
08-01 242
题目描述 Jessi初学英语，为了快速读出一串数字，编写程序将数字转换成英文： 如22：twenty two，123：one hundred and twenty three。 说明： 数字为正整数，长度不超过九位，不考虑小数，转化结果为英文小写； 输出格式为twenty two； 非法数据请返回“error”； 关键字提示：and，billion，million，thousand，...
Java基础：42 算法
weixin_44306551的博客
07-21 435
六、算法 6.1.算法概述 算法简单来说就是解决问题的步骤。 　　在Java中，算法通常都是由类的方法来实现的。前面的数据结构，比如链表为啥插入、删除快，而查找慢，平衡的二叉树插入、删除、查找都快，这都是实现这些数据结构的算法所造成的。 逻辑结构和存储结构都相同, 但运算不同, 则数据结构不同. 例如, 栈与队列 对于一种数据结构, 常见的运算 插入 删除 修改 查找 排序 算法的五个特征 ①、有穷性：对于任意一组合法输入值，在执行又穷步骤之后一定能结束，即：算法中的每个步骤都能在有限时间内完成。 ②、确定
牛客华为题库刷题笔记
qq_42762496的博客
06-29 548
笔记
刷题：华为机试 HJ50 中缀表达式转换为后缀表达式的四则运算
会编程的大厨的博客
04-14 529
中缀表达式利于我们手动计算，对于计算机而言，后缀表达式更利于计算机计算。 那么，如何将中缀表达式转换为后缀表达式，按照以下步骤即可。 ①按照运算符的优先级对所有运算符和它的运算数加括号（原本有括号的就不用再加了） ②把运算符移动到对应的括号后 ③去掉括号 同样的，将中缀表达式转化为前缀表达式，与上述过程类似： ①按照运算符的优先级对所有运算符和它的运算数加括号（原本有括号的就不用再加了） ②把运算符移动到对应的括号前 ③去掉括号 ...
刷题：华为机试 HJ36 字符串加密
会编程的大厨的博客
05-07 509
如果使用大小写转换函数，显得更整洁、更不容易出错。 toupper将小写字母转化为大写字母； tolower将大写字母转化为小写字母。 #include <iostream> #include <string> #include <algorithm> #include <vector> using namespace std; int main() { string key; string str; while (cin >&
刷题：华为机试 HJ33 整数与IP地址间的转换
会编程的大厨的博客
05-03 386
对于这道题，如果对进制转换、移位运算十分熟悉的话，做起来是十分简单的，而且很高效。如果不熟悉相关知识点，做起来费劲一些，下面的代码，对于输入IP地址转换为十进制数，采用的是比较原始的方法，代码显得冗杂；对于十进制数转换为IP地址，则使用的移位运算，代码简洁，而且运行高效。 #include <iostream> #include <vector> #include <string> #include <bitset> using namespace std;
后浇节点HJ2：HRB400钢筋与HPB300箍筋设计参数
后浇节点弯钩HJ2是结构工程中的一个重要概念，特别是在施工阶段的桥梁、高层建筑或者大跨度结构设计中，用于处理结构连接处混凝土与预应力或普通钢筋之间的接合问题。在提供的代码片段中，我们可以看到关于后浇节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值