跳至主要內容
算法题：分别用c++/python/java实现回文数

回文数是一个数字，从左到右和从右到左读都是相同的数字序列。换句话说，回文数在数值上是对称的。一些常见的回文数示例包括：

  1. 单个数字：例如1、2、3等，它们本身就是回文数，因为它们只有一个数字。

  2. 两位数：例如11、22、33等，它们也是回文数，因为它们的左右两个数字相同。

  3. 多位数：例如121、1331、1221等，这些数字从左到右和从右到左读都是相同的。

C++实现

这段代码的目标是寻找一个初始数"921"，然后反复对它执行特定的加法操作，直到找到一个回文数，或者进行30次操作后仍然找不到回文数时，打印"impossible"。

程序员诚哥大约 4 分钟算法noicspsnoip
用c++写一个高精度计算的乘法运算

这段代码是一个用C++编写的程序，它实现了两个大整数的乘法运算。

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

int main(){
    char a1[101]="222",b1[101]="2";
    int a[101],b[101],c[10001],lena,lenb,lenc,i,j,x;
    memset(a,0,sizeof(a));
    memset(b,0,sizeof(b));
    memset(c,0,sizeof(c));
    lena=strlen(a1);
    lenb= strlen(b1);

    for(i=0;i<lena;i++){
        a[lena-i]=a1[i]-48;
    }
    for(i=0;i<lenb;i++){
        b[lenb-i]=b1[i]-48;
    }

    for(i=1;i<=lena;i++){
        x=0;//用于存放进位
        for(j=1;j<=lenb;j++){//对乘数的每一位进行处理
            c[i+j-1]=a[i]*b[j]+x+c[i+j-1];//当前乘积+上次乘积进位+原数
            x=c[i+j-1]/10;
            c[i+j-1]%=10;
        }
        c[i+lenb]=x;
    }
    lenc=lena+lenb;
    while(c[lenc]==0 && lenc>1){
        lenc--;
    }
    for(i=lenc;i>=1;i--){
        cout<<c[i];
    }
    cout<<endl;
}
程序员诚哥大约 2 分钟算法noicspsnoip
用c++写一个高精度计算的除法运算

高精度除以低精度

以下这段代码的主要作用是将一个大整数（以字符数组形式表示）除以一个整数，并输出结果。具体来说，代码将大整数 a1（"1256"）除以整数 b（3），并输出商。

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

int main(){
    char a1[100]="1256";
    int a[100],c[100],lena,i,x=0,lenc,b=3;//a 用于存储被除数，c 用于存储商，x 用于保存进位，lenc 用于记录商的长度，b 是除数。
    //分别用于将数组 a 和 c 初始化为零。
    memset(a,0,sizeof(a));
    memset(c,0,sizeof(c));

    lena = strlen(a1);
    for(i=0;i<=lena-1;i++){//循环遍历被除数的字符，将其转换为整数并存储在数组 a 中。这是将字符数组形式的大整数转换为整数数组形式的关键步骤。
        a[i+1]=a1[i]-'0';
    }
    //遍历数组 a 中的每个数字，逐位执行除法操作，同时考虑上一位的余数 x。商被存储在数组 c 中，余数被保存在 x 中。
    for(i=1;i<=lena;i++){
        c[i]=(x*10+a[i])/b;//计算当前位置的值
        x=(x*10+a[i])%b;//取余，用于下一位的计算
    }
    lenc=1;//初始化商的长度。

    while(c[lenc]==0 && lenc<lena){//去除商中高位的零，同时更新商的长度 lenc。
        lenc++;
    }
    for(i=lenc;i<=lena;i++){
        cout<<c[i];
    }
    cout<<endl;
    return 0;
}
程序员诚哥大约 5 分钟算法noicspsnoip
用c++写一个高精度计算的减法运算

这段代码是一个用C++编写的程序，它实现了两个大整数的减法运算。

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

int main(){
    int a[256],b[256],c[256],lena,lenb,lenc,i;
    char n[256],n1[256]="1001",n2[256]="2001";//n1被减数，n2减数
    memset(a,0,sizeof(a));//memset用于初始化数组或一块内存区域，将其中的每个字节都设置为指定的值。将数组a的值全部初始化为0
    memset(b,0,sizeof(b));
    memset(c,0,sizeof(c));
    //如果被减数小于减数,则交换它们的值，并输出负号表示结果将为负数。
    if(strlen(n1)<strlen(n2)||(strlen(n1)==strlen(n2)&&strcmp(n1,n2)<0)){
        strcpy(n,n1);
        strcpy(n1,n2);
        strcpy(n2,n);
        cout<<"-";
    }
    lena=strlen(n1);lenb=strlen(n2);
    for(i=0;i<=lena-1;i++){
        a[lena-i]=int(n1[i]-'0');
    }
    for(i=0;i<=lenb-1;i++){
        a[lenb-i]=int(n2[i]-'0');
    }
    i=1;
    while(i<=lena||i<=lenb){
        if(a[i]<b[i]){
            a[i]+=10;//不够减，那么想高位借1当10
            a[i+1]--;
        }
        c[i]=a[i]-b[i];//对应位相减
        i++;
    }
    lenc=i;
    while((c[lenc]==0)&&(lenc>1)) {
        lenc--;//最高位的0不输出
    }
    for(i=lenc;i>=1;i--) {
        cout<<c[i];
    }
    cout<<endl;
    return 0;
}
程序员诚哥大约 3 分钟算法noicspsnoip
用c++写一个高精度计算的加法算法，输入两个正整数，求它们的和

以下是一个简单的C++程序，用于执行高精度加法操作。该程序将两个正整数作为输入，然后计算它们的和，并以字符串形式输出结果。这个程序可以处理非常大的整数。

#include<bits/stdc++.h>
using namespace std;
int a1[200],b1[200],c[200];
int main(){
    char a[200]="10012",b[200]="4";
    int lena=strlen(a);
    int lenb=strlen(b);
    for(int i=1;i<=lena;i++){
        a1[i]=a[lena-i]-'0';
    }
    for(int i=1;i<=lenb;i++){
        b1[i]=b[lenb-i]-'0';
    }
    int lenc=1;
    int x=0;
    while(lenc<=lena||lenc<=lenb){
        c[lenc]=a1[lenc]+b1[lenc]+x;
        x = c[lenc]/10;
        c[lenc]%=10;
        lenc++;
    }
    c[lenc]=x;
    while(c[lenc]==0&&lenc>1){
        lenc--;
    }
    for(int i=lenc;i>=1;i--){
        cout<<c[i];
    }
    cout<<endl;
    return 0;
}
程序员诚哥大约 5 分钟算法noicspsnoip
分别用c++,python,java写一个解决约瑟夫环问题的代码

问题描述

约瑟夫环问题是一个经典的数学和计算机科学问题，它涉及到一组人（通常用编号表示），围坐成一个圈，然后依次报数，每报到指定的数字的人将被淘汰，直到最后剩下一个人。
分别用c++,python,java写一个约瑟夫环问题的算法解决方案，将被报到的人依次打印出来，人数为8，报数为：5。

代码示例

以下是C++、Python 和 Java 中分别解决约瑟夫环问题的算法解决方案，其中有8个人，每次报数为5，并打印出被报数的人：

C++ 示例：

#include <iostream>
using namespace std;
struct node{
    long d;
    node * next;
};
long n,m;
node * head, * p, * r;
int main(){
    long i,j,k,l;
    int n=8,m=5;
    head = new node;
    head->d = 1; head->next = NULL;r=head;
    for(i=2;i<=n;i++){
        p = new node;
        p->d=i;
        p->next=NULL;
        r->next = p;
        r=p;
    }
    r->next=head;r=head;
    for(i=0;i<n;i++){
        for(j=1;j<=m-2;j++){
            r=r->next;
        }
        cout<<r->next->d<<" ";
        r->next = r->next->next;
        r=r->next;
    }
}
程序员诚哥大约 4 分钟算法noicspsnoip
分别用c++,python,java写一个行列转换的算法

分别用c++,python,java写一个行列转换的算法，将这个矩阵转换一下：[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]

以下是使用C++、Python 和 Java 编写的矩阵行列转换算法，并将给定矩阵转置的示例：

C++ 示例：

#include <iostream>
#include <vector>

int main() {
    std::vector<std::vector<int>> matrix = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9},
        {10, 11, 12}
    };

    int rows = matrix.size();
    int cols = matrix[0].size();

    // 创建一个新的矩阵来存储转置结果
    std::vector<std::vector<int>> transpose(cols, std::vector<int>(rows));

    // 转置矩阵
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            transpose[j][i] = matrix[i][j];
        }
    }

    // 打印转置矩阵
    for (int i = 0; i < cols; i++) {
        for (int j = 0; j < rows; j++) {
            std::cout << transpose[i][j] << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}
程序员诚哥大约 1 分钟算法noicspsnoip