Code – 第57页

[Java] 蓝桥杯ALGO-100 算法训练整除问题

问题描述
编写一个程序，输入三个正整数min、max和factor，然后对于min到max之间的每一个整数（包括min和max），如果它能被factor整除，就把它打印出来。
输入格式：输入只有一行，包括三个整数min、max和factor。
输出格式：输出只有一行，包括若干个整数。
输入输出样例
样例输入
1 10 3
样例输出
3 6 9

package algo100;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int min = scanner.nextInt();
        int max = scanner.nextInt();
        int factor = scanner.nextInt();
        scanner.close();
        for (int i = min; i <= max; i++) {
            if (i % factor == 0) {
                System.out.print(i + " ");
            }
        }
    }

}

package algo100;

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

int min = scanner.nextInt();

int max = scanner.nextInt();

int factor = scanner.nextInt();

scanner.close();

for (int i = min; i <= max; i++) {

if (i % factor == 0) {

System.out.print(i + " ");

}

问题描述
一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如，6的因子为1、2、3，而6＝1＋2＋3，因此6就是“完数”。又如，28的因子为1、2、4、7、14，而28＝1＋2＋4＋7＋14，因此28也是“完数”。编写一个程序，判断用户输入的一个数是否为“完数”。
输入格式：输入只有一行，即一个整数。
输出格式：输出只有一行，如果该数为完数，输出yes，否则输出no。
输入输出样例
样例输入
6
样例输出
yes

package algo103;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        scanner.close();
        int num = 1;
        for (int i = 2; i < n; i++) {
            if (n % i == 0) {
                num += i;
            }
        }
        
        if (num == n && n != 1) {
            System.out.println("yes");
        } else {
            System.out.println("no");
        }
    }

}

package algo103;

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

int n = scanner.nextInt();

scanner.close();

int num = 1;

for (int i = 2; i < n; i++) {

if (n % i == 0) {

num += i;

}

if (num == n && n != 1) {

System.out.println("yes");

} else {

System.out.println("no");

}

[Java] 蓝桥杯ALGO-111 算法训练明明的随机数

问题描述
明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤100），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。
输入格式
输入有2行，第1行为1个正整数，表示所生成的随机数的个数：
N
第2行有N个用空格隔开的正整数，为所产生的随机数。
输出格式
输出也是2行，第1行为1个正整数M，表示不相同的随机数的个数。第2行为M个用空格隔开的正整数，为从小到大排好序的不相同的随机数。
样例输入
10
20 40 32 67 40 20 89 300 400 15
样例输出
8
15 20 32 40 67 89 300 400
题目来源
计13李震摘编自NOIP06PJ01

package algo111;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] num = new int[1001];
        int cnt = 0;
        for (int i = 0; i < n; i++) {
            int x = in.nextInt();
            if (num[x] == 0) {
                cnt++;
                num[x] = 1;
            }
        }
        in.close();
        
        System.out.println(cnt);
        for (int i = 1; i <= 1000; i++) {
            if (num[i] == 1) {
                System.out.print(i + " ");
            }
        }
    }

}

package algo111;

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

int n = in.nextInt();

int[] num = new int[1001];

int cnt = 0;

for (int i = 0; i < n; i++) {

int x = in.nextInt();

if (num[x] == 0) {

cnt++;

num[x] = 1;

}

in.close();

System.out.println(cnt);

for (int i = 1; i <= 1000; i++) {

if (num[i] == 1) {

System.out.print(i + " ");

}

[Java] 蓝桥杯ALGO-113 算法训练数的统计

问题描述
在一个有限的正整数序列中，有些数会多次重复出现在这个序列中。
如序列：3，1，2，1，5，1，2。其中1就出现3次，2出现2次，3出现1 次，5出现1次。
你的任务是对于给定的正整数序列，从小到大依次输出序列中出现的数及出现的次数。
输入格式
第一行正整数n，表示给定序列中正整数的个数。
第二行是n 个用空格隔开的正整数x，代表给定的序列。
输出格式
若干行，每行两个用一个空格隔开的数，第一个是数列中出现的数，第二个是该数在序列中出现的次数。
样例输入
12
8 2 8 2 2 11 1 1 8 1 13 13
样例输出
1 3
2 3
8 3
11 1
13 2
数据规模和约定
数据：n<=1000；0<x<=1000,000。

package algo113;

import java.util.Scanner;
import java.util.SortedMap;
import java.util.TreeMap;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        SortedMap<Integer, Integer> hash = new TreeMap<>();
        for (int i = 0; i < n; i++) {
            int x = in.nextInt();
            if (!hash.containsKey(x)) {
                hash.put(x, 1);
            } else {
                int cnt = hash.get(x) + 1;
                hash.put(x, cnt);
            }
        }
        in.close();

        for (Integer key : hash.keySet()) {
            System.out.println(key + " " + hash.get(key));
        }
    }

}

package algo113;

import java.util.Scanner;

import java.util.SortedMap;

import java.util.TreeMap;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

int n = in.nextInt();

SortedMap<Integer, Integer> hash = new TreeMap<>();

for (int i = 0; i < n; i++) {

int x = in.nextInt();

if (!hash.containsKey(x)) {

hash.put(x, 1);

} else {

int cnt = hash.get(x) + 1;

hash.put(x, cnt);

}

in.close();

for (Integer key : hash.keySet()) {

System.out.println(key + " " + hash.get(key));

}

[Java] 蓝桥杯ALGO-115 算法训练和为T

问题描述
从一个大小为n的整数集中选取一些元素，使得它们的和等于给定的值T。每个元素限选一次，不能一个都不选。
输入格式
第一行一个正整数n，表示整数集内元素的个数。
第二行n个整数，用空格隔开。
第三行一个整数T，表示要达到的和。
输出格式
输出有若干行，每行输出一组解，即所选取的数字，按照输入中的顺序排列。
若有多组解，优先输出不包含第n个整数的；若都包含或都不包含，优先输出不包含第n-1个整数的，依次类推。
最后一行输出总方案数。
样例输入
5
-7 -3 -2 5 9
0
样例输出
-3 -2 5
-7 -2 9
2
数据规模和约定
1<=n<=22
T<=maxlongint
集合中任意元素的和都不超过long的范围

package algo115;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Scanner;
import java.util.Stack;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        isVisited = new boolean[n];
        nums = new int[n];
        for (int i = 0; i < n; i++) {
            nums[i] = sc.nextInt();
        }
        t = sc.nextInt();
        sc.close();
        dfs(n - 1, 0, new LinkedList(), true);
        while (!out.isEmpty()) {
            System.out.println(out.pop());
        }
        System.out.println(cnt);
    }
    
    private static int cnt = 0, n = 0, t = 0;
    private static boolean[] isVisited;
    private static int[] nums;
    private static Stack out = new Stack<>();
    
    private static void dfs(int pos, int tempT, LinkedList selectedNums, boolean isNone) {
        for (int i = pos; i >= 0; i--) {
            if (!isVisited[i]) {
                isVisited[i] = true;
                selectedNums.push(nums[i]);
                dfs(i - 1, tempT + nums[i], selectedNums, false);
                selectedNums.pop();
                isVisited[i] = false;
            }
        }
        if (tempT == t && !isNone) {
            out.push(toReulstString(selectedNums.iterator()));
            cnt++;
        }
    }
    
    private static String toReulstString(Iterator it) {
        StringBuilder result = new StringBuilder();
        while (it.hasNext()) {
            result.append(it.next() + " ");
        }
        return result.toString();
    }
}

package algo115;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.Scanner;

import java.util.Stack;

public class Main {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

n = sc.nextInt();

isVisited = new boolean[n];

nums = new int[n];

for (int i = 0; i < n; i++) {

nums[i] = sc.nextInt();

}

t = sc.nextInt();

sc.close();

dfs(n - 1, 0, new LinkedList(), true);

while (!out.isEmpty()) {

System.out.println(out.pop());

}

System.out.println(cnt);

}

private static int cnt = 0, n = 0, t = 0;

private static boolean[] isVisited;

private static int[] nums;

private static Stack out = new Stack<>();

private static void dfs(int pos, int tempT, LinkedList selectedNums, boolean isNone) {

for (int i = pos; i >= 0; i--) {

if (!isVisited[i]) {

isVisited[i] = true;

selectedNums.push(nums[i]);

dfs(i - 1, tempT + nums[i], selectedNums, false);

selectedNums.pop();

isVisited[i] = false;

}

if (tempT == t && !isNone) {

out.push(toReulstString(selectedNums.iterator()));

cnt++;

}

private static String toReulstString(Iterator it) {

StringBuilder result = new StringBuilder();

while (it.hasNext()) {

result.append(it.next() + " ");

}

return result.toString();

}

[Java] 蓝桥杯ALGO-117 算法训练友好数

问题描述
有两个整数，如果每个整数的约数和（除了它本身以外）等于对方，我们就称这对数是友好的。例如：
9的约数和有：1+3=4
4的约数和有：1+2=3
所以9和4不是友好的。
220的约数和有：1 2 4 5 10 11 20 22 44 55 110=284
284的约数和有：1 2 4 71 142=220
所以220和284是友好的。
编写程序，判断两个数是否是友好数。
输入格式
一行，两个整数，由空格分隔
输出格式
如果是友好数，输出”yes”，否则输出”no”，注意不包含引号。
样例输入
220 284
样例输出
yes
数据规模和约定
两个整数都小于10000

package algo117;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int a = in.nextInt();
        int b = in.nextInt();
        in.close();
        if (b == factor(a) && a == factor(b)) {
            System.out.println("yes");
        } else {
            System.out.println("no");
        }
    }
    
    private static int factor(int a) {
        int sum = 0;
        for (int i = 1; i < a; i++) {
            if (a % i == 0) {
                sum += i;
            }
        }
        return sum;
    }

}

package algo117;

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

int a = in.nextInt();

int b = in.nextInt();

in.close();

if (b == factor(a) && a == factor(b)) {

System.out.println("yes");

} else {

System.out.println("no");

}

private static int factor(int a) {

int sum = 0;

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

if (a % i == 0) {

sum += i;

}

return sum;

}

分类： Code

[Java] 蓝桥杯ALGO-100 算法训练整除问题

[Java] 蓝桥杯ALGO-103 算法训练完数

[Java] 蓝桥杯ALGO-111 算法训练明明的随机数

[Java] 蓝桥杯ALGO-113 算法训练数的统计

[Java] 蓝桥杯ALGO-115 算法训练和为T

[Java] 蓝桥杯ALGO-117 算法训练友好数