HDU - 1042 N!(高精度BigInt)

N!

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others)
Total Submission(s): 86335    Accepted Submission(s): 25398


Problem Description
Given an integer N(0 ≤ N ≤ 10000), your task is to calculate N!
 

Input
One N in one line, process to the end of file.
 

Output
For each N, output N! in one line.
 

Sample Input
  
1 2 3
 

Sample Output
  
1 2 6
 

Author
JGShining(极光炫影)
 

Recommend
We have carefully selected several similar problems for you:   1715  1047  1063  1753  1316 
 
#include <bits/stdc++.h>
using namespace std;

const int N = 1e4 + 10;
int n;
struct BigInt
{
    const static int Mod = 10000;
    const static int LEN = 4;
    int a[N], len;
    BigInt(){
        memset(a, 0, sizeof a);
        len = 1;
    }
    void init(int x){
        memset(a, 0, sizeof a);
        len = 0;
        do{
            a[len++] = x%Mod;
            x /= Mod;
        }while(x);
    }
    int Compare(const BigInt &b){  /// a>b 1, a=b 0, a<b -1
        if(len < b.len) return -1;
        if(len > b.len) return 1;
        for(int i = len-1; i >= 0; i--)
            if(a[i] < b.a[i])return -1;
            else if(a[i] > b.a[i])return 1;
        return 0;
    }
    BigInt operator +(const BigInt &b)const{
        BigInt ans;
        ans.len = max(len, b.len);
        for(int i = 0; i <= ans.len; i++) ans.a[i] = 0;
        for(int i = 0; i< ans.len; i++){
            ans.a[i] += ((i < len) ? a[i] : 0)+((i < b.len) ? b.a[i] : 0);
            ans.a[i+1] += ans.a[i]/Mod;
            ans.a[i] %= Mod;
        }
        if(ans.a[ans.len] > 0)ans.len++;
        return ans;
    }
    BigInt operator -(const BigInt &b)const{
        BigInt ans;
        ans.len = len;
        int k = 0;
        for(int i = 0; i < ans.len; i++){
            ans.a[i] = a[i]+k-b.a[i];
            if(ans.a[i] < 0) ans.a[i] += Mod,k = -1;
            else k = 0;
        }
        while(ans.a[ans.len-1] == 0 && ans.len > 1) ans.len--;
        return ans;
    }
    BigInt operator *(const BigInt &b)const{
        BigInt ans;
        for(int i = 0; i < len;i++){
            int k = 0;
            for(int j = 0; j < b.len; j++){
                int temp = a[i]*b.a[j]+ans.a[i+j]+k;
                ans.a[i+j] = temp%Mod;
                k = temp/Mod;
            }
            if(k != 0) ans.a[i+b.len] = k;
        }
        ans.len = len+b.len;
        while(ans.a[ans.len-1] == 0 && ans.len > 1)ans.len--;
        return ans;
    }
    void output(){
        printf("%d", a[len-1]);
        for(int i = len-2; i >= 0; i--)
            printf("%04d", a[i]);
        printf("\n");
    }
};

int main(){
    while(scanf("%d", &n) == 1){
        BigInt ans, x;
        ans.init(1);
        for(int i = 2;i <= n; i++){
            x.init(i);
            ans = ans*x;
        }
        ans.output();
    }
}


内容概要:本文详细记录了对一个Android ARM64静态ELF文件中字符串加密机制的逆向分析过程。该ELF文件的所有字符串均被加密,无法通过常规strings命令或IDA直接识别。作者通过分析发现,加密字符串存储在.rodata段,其解密所需信息(包括密文地址、长度和16位密钥)保存在.data.rel.ro段的40字节描述符中。核心解密函数sub_10F408采用自反的双pass流密码算法,结合固定密钥KEY_TERM(由.data段24字节数据计算得出),实现字节级非线性、位置与长度相关的加密。文章还复现了完整的Python解密脚本,并揭示了该保护机制的本质为代码混淆而非强加密,最终成功批量解密全部956条字符串,暴露程序真实行为,如shell命令模板、设备标识篡改、网络重置等操作。此外,文中还提及未启用的自定义壳框架及其反dump设计。; 适合人群:具备逆向工程基础的安全研究人员、二进制分析人员及对ELF保护技术感兴趣的开发者。; 使用场景及目标:①学习ELF二进制中字符串加密的典型实现方式与逆向突破口;②掌握从结构识别、函数追踪到算法还原的完整逆向流程;③理解“绑定二进制”的完整性校验设计及其局限性;④实践编写IDAPython脚本自动化提取与解密敏感数据。; 阅读建议:此资源以实战案例驱动,不仅展示技术细节,更强调逆向思维与验证方法,建议读者结合IDA调试环境,逐步跟随文中步骤进行动态分析与算法验证,深入理解每一步的推理依据。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值