ACM no.54 no.62

no.54
描述

小明的零花钱一直都是自己管理。每个月的月初妈妈给小明300元钱，小明会预算这个月的花销，并且总能做到实际花销和预算的相同。
为了让小明学习如何储蓄，妈妈提出，小明可以随时把整百的钱存在她那里，到了年末她会加上20％还给小明。因此小明制定了一个储蓄计划：每个月的月初，在得到妈妈给的零花钱后，如果他预计到这个月的月末手中还会有多于100元或恰好100元，他就会把整百的钱存在妈妈那里，剩余的钱留在自己手中。
例如11月初小明手中还有83元，妈妈给了小明300元。小明预计11月的花销是180元，那么他就会在妈妈那里存200元，自己留下183元。到了11月月末，小明手中会剩下3元钱。
小明发现这个储蓄计划的主要风险是，存在妈妈那里的钱在年末之前不能取出。有可能在某个月的月初，小明手中的钱加上这个月妈妈给的钱，不够这个月的原定预算。如果出现这种情况，小明将不得不在这个月省吃俭用，压缩预算。
现在请你根据2010年1月到12月每个月小明的预算，判断会不会出现这种情况。如果不会，计算到2010年年末，妈妈将小明平常存的钱加上20％还给小明之后，小明手中会有多少钱。 

输入
第一行输入一个整数N，表示测试数据的组数（N<=10)
每组测试数据输入12行数据，每行包含一个小于350的非负整数，
分别表示1月到12月小明的预算。

输出
输出-X，X表示出现这种情况的第一个月；否则输出到2010年年末小明手中
会有多少钱(如果是小数，请四舍五入到整数位）。

public class no54 
{
    public int method(int[][] a)
    {

        for(int i=0;i<a.length;i++)
        {
            int lest=0;
            int mum=0;
            boolean charge=true;
            for(int j=0;j<a[i].length;j++)
            {
                lest+=300;
                lest=lest-a[i][j];
                if(lest<0)
                {
                    System.out.println(-(j+1));
                    charge=false;
                    break;
                }
                else if(lest>=100)
                {
                    int bai=lest/100;
                    mum+=bai*100;
                    lest=lest%100;
                }
            }
            if(charge==true)
                System.out.println("余额为"+(lest+(mum*=1.2)));
        }
        return 0;   
    }

    public static void main(String[] args)
    {
        no54 c1 = new no54();
        Scanner input=new Scanner(System.in);
        int n=input.nextInt();
        int[][] a=new int[n][12];
        for(int i=0;i<a.length;i++)
        {
            for(int j=0;j<a[i].length;j++)
            {
                a[i][j]=input.nextInt();
            }
        }
            c1.method(a);


    }
}

no.62
描述

笨小熊的词汇量很小，所以每次做英语选择题的时候都很头疼。但是他找到了一种方法，经试验证明，用这种方法去选择选项的时候选对的几率非常大！
这种方法的具体描述如下：假设maxn是单词中出现次数最多的字母的出现次数，minn是单词中出现次数最少的字母的出现次数，如果maxn-minn是一个质数，那么笨小熊就认为这是个Lucky Word，这样的单词很可能就是正确的答案。 
输入
第一行数据N(0<N<100)表示测试数据组数。
每组测试数据输入只有一行，是一个单词，其中只可能出现小写字母，并且长度小于100。 
输出
每组测试数据输出共两行，第一行是一个字符串，假设输入的的单词是Lucky Word，
那么输出“Lucky Word”，否则输出“No Answer”；
第二行是一个整数，如果输入单词是Lucky Word，输出maxn-minn的值，否则输出0

package 练习;

import java.util.Scanner;

public class no62 
{   
    public boolean isSuShu(int m)
    {
        boolean result=true;
        if(m==0 || m==1)
            return !result;
        for(int i=2;i<m;i++)
        {
            if(m%i==0)
            {
                result=false;
                break;
            }
        }
        return result;
    }

    public void method(String[] m)
    {
        for(int j=0;j<m.length;j++)
        {
            int min=1,max=1,sum=0;
            char[] chr=m[j].toCharArray();
            for(int k=0;k<chr.length;k++)
            {
                char c =chr[k];
                int count=0;
                for(int l=0;l<chr.length;l++)
                {
                    if(c==chr[l])
                    {
                        count++;
                        if(count>=max)
                            max=count;
                        if(count<=min)
                            min=count;
                    }
                }
                if(count>sum)
                    sum=count;
            }

            int balance=sum-min;
            if(isSuShu(balance))
                System.out.println("lucky word");
            else
                System.out.println("no answer "+"\n"+0);
        }
    }

    public static void main(String[] args)
    {
        no62 c1=new no62();
        Scanner input = new Scanner(System.in);
        int a=input.nextInt();
        String[] str = new String[a];
        for(int i=0;i<str.length;i++)
        {
            str[i]=input.next();
        }

        c1.method(str);
        input.close();
    }
}

no.24
描述
    现在给出你一些数，要求你写出一个程序，输出这些整数相邻最近的素数，
    并输出其相距长度。如果左右有等距离长度素数，则输出左侧的值及相应距离。
    如果输入的整数本身就是素数，则输出该素数本身，距离输出0

输入
第一行给出测试数据组数N(0<N<=10000)
接下来的N行每行有一个整数M(0<M<1000000)，
输出
每行输出两个整数 A B.
其中A表示离相应测试数据最近的素数，B表示其间的距离。

public class no24 
{
    public boolean isSuShu(int m)
    {
        boolean result=true;
        for(int i=2;i<m;i++)
        {
            if(m%i==0)
            {
                result=false;
                break;
            }
        }
        return result;
    }
    public int getleft(int m)
    {
        int num=m-1;
        boolean res;
        for(;num>0;num--)
        {
            res=isSuShu(num);
            if(res==true)
                return num;
        }
        return 0;
    }
    public int getright(int m)
    {
        boolean resu;
        int num=m+1;
        for(;num>m;num++)
        {
            resu=isSuShu(num);
            if(resu==true)
                return num;
        }
        return 0;

    }

    public static void main(String[] args)
    {
        no24 c1 = new no24();
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        int []b=new int[n];
        for(int i=0;i<b.length;i++)
        {
            b[i]=input.nextInt();
        }
        for(int j=0;j<b.length;j++)
        {
            int l,r;
            if(c1.isSuShu(b[j])==true)
            {
                System.out.println(b[j]+" "+0);
                continue;
            }
            l=b[j]-c1.getleft(b[j]);
            r=c1.getright(b[j])-b[j];
            if(l>r)
                System.out.println(c1.getright(b[j])+" "+r);
            else
                System.out.println(c1.getleft(b[j])+" "+l);
        }
    }
}