【蓝桥杯VIP】试题 历届试题 带分数（满分 Python解法+Java解法）

【蓝桥杯VIP】试题 历届试题 带分数（满分 Python解法+Java解法）

资源限制
时间限制：1.0s 内存限制：256.0MB

问题描述
100 可以表示为带分数的形式：100 = 3 + 69258 / 714。
还可以表示为：100 = 82 + 3546 / 197。
注意特征：带分数中，数字1~9分别出现且只出现一次（不包含0）。
类似这样的带分数，100 有 11 种表示法。

输入格式
从标准输入读入一个正整数N (N<1000*1000)

输出格式
程序输出该数字用数码1~9不重复不遗漏地组成带分数表示的全部种数。
注意：不要求输出每个表示，只统计有多少表示法！

样例输入1
100

样例输出1
11

样例输入2
105

样例输出2
6

Python解法：

"""
#复制列表的简易方法：
L=[34,65,2,1,86,0]
L1=[j for j in L]
L.append((12,12))
print(L)    # [34, 65, 2, 1, 86, 0, (12, 12)]
print(L1)    # [34, 65, 2, 1, 86, 0]

list1=["1","2","3","4","5","6","7","8","9"]
list1.sort(reverse=True)
print(list1)   # ['9', '8', '7', '6', '5', '4', '3', '2', '1'] 

"""


# 100分
# 判断 i是否存在重复数字 并 判断 i是否存在li没有的数字
def check(i,li):
    li1=list(str(i))
    li2=list(set(li1))
    flag=True
    if len(li1)==len(li2):  #判断 i是否存在重复数字
        for j in li1:
            if j not in li:    #判断 i是否存在li没有的数字
                flag=False
                break
    else:
        flag=False
    return flag


N=int(input())
list1=["1","2","3","4","5","6","7","8","9"]
count=0

'''
假设：N=a+b/c
'''

#遍历整数 a
for a in range(1,N):

    if check(a, list1)==False:
        continue

    #复制list1
    list2=[k for k in list1]

    #删除出现在a的元素
    for j in str(a):
        list2.remove(j)

    #遍历分母 c
    for c in range(1,10**5):   #简单分析可知：分母的最大范围是四位数

        if check(c,list2)==False:
            continue

        b=(N-a)*c

        if len(str(b))+len(str(c))>len(list2):
            '''
            list2的长度是符合要求的分子和分母的总长，如果此时的分子和分母的总长大于list2的长度，
            则说明该分子j不符合要求且因为j是不断增长的，因此以后的j也会不符合要求，此时需要直接跳出循环.
            '''
            break

        if check(b, list2)==False or len(str(b))+len(str(c))!=len(list2):
            continue

        #复制list2
        list3=[k for k in list2]

        #删除出现在b的元素
        for j in str(b):
            list3.remove(j)

        #因为list3的范围要比list2小，所以此时还要再判断c中是否存在list3中不存在的数字
        if check(c,list3)==True and len(str(c))==len(list3):
            count+=1

print(count)

Java解法:

// 100分
import java.util.*;

public class Main {

    /*
    假设：N=a+b/c
    */
    
    private static int N;
    private static int count=0;
    private static List<String> list1=new ArrayList<String>();
//    private static List<String> list2=new ArrayList<String>();
//    private static List<String> list3=new ArrayList<String>();

    public static void main(String[] args){

        Scanner scan=new Scanner(System.in);
        N=scan.nextInt();

        //给list1赋值
        Collections.addAll(list1,"1","2","3","4","5","6","7","8","9");

        for(int a=1;a<N;a++){

            if(check(a,list1)==false){
                continue;
            }

            //复制list1
            List<String> list2=new ArrayList<String>();
            list2.addAll(list1);

            //删除list1与 a中同时出现的数字
            String[] str1=Integer.toString(a).split("");
            for(int i=0;i<str1.length;i++){
                list2.remove(str1[i]);
            }

            //遍历字母 c
            for(int c=1;c<100000;c++){    //简单分析可知：分母的最大范围是四位数

                if(check(c,list2)==false){
                    continue;
                }

                int b=(N-a)*c;

                String[] str2=Integer.toString(b).split("");
                String[] str3=Integer.toString(c).split("");
                /*
                list2的长度是符合要求的分子和分母的总长，如果此时的分子和分母的总长大于list2的长度，
                则说明该分子j不符合要求且因为j是不断增长的，因此以后的j也会不符合要求，此时需要直接跳出循环.
                 */
                if(str2.length+str3.length>list2.size()){
                    break;
                }

                if(check(b,list2)==false || str2.length+str3.length!=list2.size()){
                    continue;
                }

                //复制list2
                List<String> list3=new ArrayList<String>();
                list3.addAll(list2);

                //删除list1与 b中同时出现的数字
                for(int i=0;i<str2.length;i++){
                    list3.remove(str2[i]);
                }

                //因为list3的范围要比list2小，所以此时还要再判断c中是否存在list3中不存在的数字
                if(check(c,list3)==true && str3.length==list3.size()){
                    count++;
                }

            }

        }

        System.out.println(count);


    }


    //判断 n是否存在重复数字 并 判断 n是否存在li没有的数字
    public static boolean check(int n,List li){

        String[] arr1=Integer.toString(n).split("");
        boolean isFlag=true;
        for(int i=0;i< arr1.length;i++){   //判断 i是否存在重复数字
            for(int j=i+1;j< arr1.length;j++){
                if(arr1[i].equals(arr1[j])){
                    isFlag=false;
                    break;
                }
            }

            if(isFlag==false){
                return isFlag;
            }

        }


        for(int i=0;i< arr1.length;i++){      //判断 i是否存在li没有的数字
            isFlag=false;
            for(int j=0;j<li.size();j++){
                if(arr1[i].equals(li.get(j))){
                    isFlag=true;
                    break;
                }
            }

            if(isFlag==false){
                break;
            }

        }

        return isFlag;

    }

}