幂运算

###python3#####
###把浮点型转化为整数（比如95.123转化为95123 ），再做n次方运算95123**12
###计算最后小数点的位置.123 小数有3位 12次方后 那就是3*12=16位
###由于最后得到的整数长度可能会小于小数点需要移动的长度所以要加个补零操作
###最后由于一开始没对a的末尾进行去0，所以最后进行去0操作
if __name__=='__main__':
    while 1:
        try:
            a,b=input().split()
            index=a.find('.')
            #把浮点转整数
            aint=int(a[:index]+a[index+1:])
            b=int(b)
            ###计算最后小数点的位置
            zeros=(len(a)-index-1)*b
            orint=str(aint**b)
            j=len(orint)
            #补零
            if j<=zeros: orint='0'*(zeros+1-j)+orint
            c=len(orint)-zeros
            #去0操作
            print(orint[:c]+'.'+str(int(orint[c:][::-1]))[::-1])
        except:
            break

string bigNbrMuti(string lf, string rh)
{
    int lfSize = lf.size();
    int rhSize = rh.size();
    vector<int> posRcrd(lfSize + rhSize,0);

    for (int rhPos = rhSize-1; rhPos >=0 ; rhPos--)
    {
        int rhPosVal = rh[rhPos] - '0';
        for (int lfPos = lfSize-1; lfPos >=0; lfPos--)
        {
            int lfPosVal = lf[lfPos]-'0';
            posRcrd[rhPos + lfPos+1] += lfPosVal*rhPosVal;
        }
        for (int i = lfSize + rhSize - 1; i >=1 ; i--)
        {
            while (posRcrd[i] >= 10)
            {
                posRcrd[i] -= 10;
                posRcrd[i - 1] += 1;
            }
        }
    }
    string reslut;
    for (int i = 0; i < lfSize + rhSize; i++)
    {
        if (0 == i && 0 == posRcrd[i])
        {
            continue;
        }            
        reslut.push_back('0' + (char)(posRcrd[i]));

    }
    return reslut;
}
void test(void)
{
    string r;
    int n;
    while (cin >> r >> n)
    {
        string intNbr;
        int posOfPoint = -1;
        //祛除小数点后得到一个整数并记录小数点的位置
        for (int i = 0; i < r.size(); i++)
        {
            if (r[i] != '.')
            {
                intNbr.push_back(r[i]);
            }
            else
            {
                posOfPoint = i;
            }
        }
        int validSize = intNbr.size();
        //去除123.100这种情况后面的0，获得有效位的大小
        if (posOfPoint != -1)
        {
            for (int i = r.size() - 1; i >= 0; i--)
            {
                if (r[i] == '0')
                {
                    intNbr.pop_back();
                    validSize--;
                }
                else
                {
                    break;
                }
            }
        }
        string result = intNbr;
        //大数乘法
        for (int i = 0; i < n - 1; i++)
        {
            result = bigNbrMuti(result, intNbr);
        }
        //计算小数点的位置
        if (posOfPoint != -1)
        {
            int nbrOfFrac = validSize - posOfPoint;
            int posOfPointInResult = nbrOfFrac*n;
            result.push_back('0');
            int count = 0;
            int i;
            for (i = result.size() - 1; count != posOfPointInResult; i--)
            {
                result[i] = result[i - 1];
                count++;
            }
            result[i] = '.';
        }
        cout << result << endl;
    }

```
}

人生苦短，我用Python

import re
def float_format(result_int, decimal_number):
    result_str = str(result_int)
    if len(result_str) <= decimal_number:
        result = '%0{}d'.format(decimal_number) %result_int
        result = '0.' + result
    else:
        left_result = result_str[:-decimal_number]
        right_result = result_str[-decimal_number:]
        result = '.'.join([left_result, right_result])
    return result.rstrip('0').rstrip('.')

a = input()
row_list = a.split('\n')
for row in row_list:
    a = re.split('\s+', row)[0]
    b = re.split('\s+', row)[1]
    str_len = len(a)
    point_pos = a.find('.')
    decimal_number = str_len - 1 -point_pos
    a_int = int(a.replace('.', ''))
    b_int = int(b)
    result_int = a_int ** b_int
    result = float_format(result_int, decimal_number * int(b))
    print(result)

#include <iostream>
#include <vector>
#include <string>

using namespace std;

string getTheMultiString(string& res, string& str)
{
    int len1 = str.size(), len2 = res.size();
    string ret(len1 + len2, '0');
    for(int i = len2 - 1; i >= 0; --i)
    {
        for(int j = len1 - 1; j >= 0; --j)
        {
            int tmp = ret[i + j + 1] - '0' + (str[j] - '0') * (res[i] - '0');
            ret[i + j + 1] = tmp % 10 + '0';
            ret[i + j] += tmp / 10;
        }
    }
    
    for(int i = 0; i < ret.size(); ++i)
    {
        if(ret[i]!= '0')
            return ret.substr(i);
    }
    
    return "0";
}
int main()
{
    string str;
    int n = 0;
    while(cin >> str >> n)
    {
        auto index = str.find('.');
        if(index != string::npos)
            str.erase(str.begin() + index, str.begin() + index + 1);
        string res = str;
        for(int i = 0; i < n - 1; ++i)
            res = getTheMultiString(res, str);
        
        if(index != string::npos)
        {
            int retindex = (str.size() - index) * n;
            while(n >= res.size())
                res.insert(res.begin(), '0');
                
            res.insert(res.end() - retindex, '.');
            auto zero = res.find_last_not_of('0');
            if(zero != string::npos)
                res.erase(res.begin() + zero + 1, res.end());
        }
        
        cout << res << endl;
    }
    
    return 0;
}

public class Main { public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);  String str = scan.nextLine();  String[] strings = str.split(" ");  if(strings.length%2 != 0){
            System.out.println("输入错误");  }else{ for(int i = 1 ;i<strings.length;i+=2){
                BigDecimal b = new BigDecimal(strings[i-1]);  System.out.println(b.pow(Integer.parseInt(strings[i])));  }
        }
    }
}

import java.util.*;
public class Main{
  public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            //用Double处理后面的0，才能计算正确的小数点位置
            String s=Double.valueOf(sc.next()).toString();
            int n=sc.nextInt();
            int l=s.length();
            int t=s.indexOf('.');
            //最后小数点位置
            int index=(l-t-1)*n;
            String ss=s.substring(0,t)+s.substring(t+1);
            String res=ss;
            for(int i=1;i<n;i++){
                res=Multiply(res,ss);
            }
            StringBuilder sb=new StringBuilder();
            for(int i=res.length()-1;i>=0;i--){
                if(index==0){
                    sb.append('.');
                }
                sb.append(res.charAt(i));
                index--;
            }
            //输入的数比1小时
            while(index>=0){
                if(index==0){
                    sb.append(".0");
                }else{
                    sb.append('0');
                }
                index--;
            }
            System.out.println(sb.reverse());
        }
    }
    
    //大数相乘
    private static String Multiply(String num1,String num2){
        int l=num1.length();
        int n=num2.length();
        //长度位m的数乘以长度为n的数的结果不超过m+n
        int[] pos=new int[l+n];
        for(int i=l-1;i>=0;i--){
            for(int j=n-1;j>=0;j--){
                int temp=(num1.charAt(i)-'0')*(num2.charAt(j)-'0');
                //对于num[i] *num[j]（数1中的第i位数字与数2中的第j位数字相乘的结果
                //只会存放在第[i+j]和[i+j+1]这两位上
                int p1=i+j;
                int p2=i+j+1;
                int sum=temp+pos[p2];
                //p1为进位
                pos[p1]+=sum/10;
                pos[p2]=sum%10;
            }
        }
        StringBuffer sb =new StringBuffer();
        for(int p:pos){
            if(!(sb.length()==0&&p==0)){
                sb.append(p);
            }
        }
        return sb.toString();
    }
}

#大数相乘
def jinWei(a,b):
    v=a+b
    if v>9:
        return [v-10,1]
    else:
        return [v,0]

def jinWei2(res,k,x):
    v=res[k+x]+1
    if v>9:
        res[k+x]=0
        jinWei2(res,k,x-1)
    else:
        res[k+x]=v

def listToStr(a):
    sss=''
    for y in range(len(a)):
        sss+=str(a[y])
    return sss

s=list(input().split())
rr=[]
for i in range(0,len(s),2):
    r=s[i]
    n=int(s[i+1])
    if n==0:
        rr.append('1')
    elif n==1:
        rr.append(r)
    else:
        idx=r.index('.')
        count=(len(r)-idx-1)*n
        m=int(r[:idx]+r[idx+1:])
        m=str(m)
        m1 = m
        result=[]
        for j in range(1,n):
            p = len(m)+len(m1)
            res=[0]*p
            for k in range(len(m)-1,-1,-1):
                for x in range(len(m1)-1,-1,-1):
                    c=int(m[k])*int(m1[x])
                    c1=c//10
                    c2=c%10
                    val=jinWei(res[k+x+1],c2)
                    res[k+x+1]=val[0]
                    if val[1]==1:
                        jinWei2(res,k,x)
                    val1=jinWei(res[k+x],c1)
                    res[k+x]=val1[0]
                    if val1[1]==1:
                        jinWei2(res,k,x-1)
            if res[0]==0:
                res=res[1:]
            m1=listToStr(res)
            result=res[:]
        length=len(result)
        if length<count:
            for j in range(count-length):
                result.insert(0,0)
            result.insert(0,'0.')
            rr.append(listToStr(result).rstrip('0'))
        else:
            result.insert(length-count,'.')
            ss=listToStr(result).rstrip('0')
            if ss[len(ss)-1]=='.':
                rr.append(ss[:len(ss)-2])
            else:
                rr.append(ss)
print(' '.join(rr[i] for i in range(len(rr))))

public class Main {
    public static void main(String[] args) throws IOException {
         //使用了BigDecimal来记录大浮点数,代码看起来比较简洁
        Scanner sc = new Scanner(System.in);
        BigDecimal bString = new BigDecimal(sc.next());
        int i = sc.nextInt();
        BigDecimal multiply = bString;
        for (int j = 1; j < i; j++) {
            multiply = multiply.multiply(bString);
        }
        System.out.println(multiply.stripTrailingZeros().toPlainString());
    }
}

	

import java.math.BigDecimal;
import java.util.Scanner;

public class Main {

   public static void main(String[] args) {
      try(Scanner in = new Scanner(System.in)) {
         while(in.hasNext()) {
            System.out.println(new BigDecimal(in.next()).pow(in.nextInt()).stripTrailingZeros().toPlainString());
         }
      }
   }
}