题目描述
牛牛有一个正整数x,牛牛需要把数字x中的数位进行重排得到一个新数(不同于x的数),牛牛想知道这个新数是否可能是原x的倍数。请你来帮他解决这个问题。
输入描述:
输入包括t+1行,第一行包括一个整数t(1 ≤ t ≤ 10), 接下来t行,每行一个整数x(1 ≤ x ≤ 10^6)
输出描述:
对于每个x,如果可能重排之后变为自己的倍数输出"Possible", 否则输出"Impossible".
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
InputStreamReader inputStreamReader = new InputStreamReader(System.in);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
Integer num = Integer.valueOf(bufferedReader.readLine());
String[] argStr = new String[num];
for (int i = 0; i < num; i++) {
argStr[i] = bufferedReader.readLine();
}
for (int i = 0; i < num; i++) {
Long origin = Long.valueOf(argStr[i]);
Integer originNum = argStr[i].length();
Long half = 5L;
for (int j = 0; j < originNum - 1; j++) {
half *= 10;
}
if (half <= origin) {
System.out.println("Impossible");
continue;
}
Boolean goon = true;
Integer step = 2;
a:
while (goon) {
Long temp = origin * step;
if (String.valueOf(temp).length() > originNum) {
System.out.println("Impossible");
goon = false;
} else {
char[] tempChar = String.valueOf(temp).toCharArray();
char[] originChar = argStr[i].toCharArray();
for (int m = 0; m < originNum; m++) {
char c = tempChar[m];
Boolean isIn = false;
for (int n = 0; n < originNum; n++) {
if (originChar[n] == c) {
originChar[n] = '-';
isIn = true;
break;
}
}
if (!isIn) {
step++;
continue a;
}
}
System.out.println("Possible");
goon = false;
}
}
}
}
}
题目描述
给出平面上的n个点，现在需要你求出，在这n个点里选3个点能构成一个三角形的方案有几种。
输入描述:
第一行包含一个正整数n，表示平面上有n个点（n <= 100) 第2行到第n + 1行，每行有两个整数，表示这个点的x坐标和y坐标。(所有坐标的绝对值小于等于100，且保证所有坐标不同）
输出描述:
输出一个数，表示能构成三角形的方案数。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) throws IOException {
Main main = new Main();
main.deal();
}
public void deal() throws IOException {
InputStreamReader inputStreamReader = new InputStreamReader(System.in);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
Integer num = Integer.valueOf(bufferedReader.readLine());
List<Node> list = new ArrayList<>();
for(int i = 0; i < num; i++) {
String[] args = bufferedReader.readLine().split(" ");
list.add(new Node(Integer.parseInt(args[0]), Integer.parseInt(args[1])));
}
Integer result = 0;
for(int a = 0; a < num - 2; a++) {
Node an = list.get(a);
for(int b = a + 1; b < num - 1; b++) {
Node bn = list.get(b);
for(int c = b + 1; c < num; c++) {
Node cn = list.get(c);
if((an.x - bn.x) * (an.y - cn.y) != (an.x - cn.x) * (an.y - bn.y)) {
result++;
}
}
}
}
System.out.println(result);
}
class Node {
int x;
int y;
public Node(int x, int y) {
this.x = x;
this.y = y;
}
}
}
题目描述
有n只小熊，他们有着各不相同的战斗力。每次他们吃糖时，会按照战斗力来排，战斗力高的小熊拥有优先选择权。前面的小熊吃饱了，后面的小熊才能吃。每只小熊有一个饥饿值，每次进食的时候，小熊们会选择最大的能填饱自己当前饥饿值的那颗糖来吃，可能吃完没饱会重复上述过程，但不会选择吃撑。
现在给出n只小熊的战斗力和饥饿值，并且给出m颗糖能填饱的饥饿值。
求所有小熊进食完之后，每只小熊剩余的饥饿值。
输入描述:
第一行两个正整数n和m，分别表示小熊数量和糖的数量。（n <= 10, m <= 100） 第二行m个正整数，每个表示着颗糖能填充的饥饿值。 接下来的n行，每行2个正整数，分别代表每只小熊的战斗力和当前饥饿值。 题目中所有输入的数值小于等于100。
输出描述:
输出n行，每行一个整数，代表每只小熊剩余的饥饿值。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
InputStreamReader inputStreamReader = new InputStreamReader(System.in);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
String[] num = bufferedReader.readLine().split(" ");
Integer bearNum = Integer.parseInt(num[0]);
Integer candyNum = Integer.parseInt(num[1]);
String[] candyStr = bufferedReader.readLine().split(" ");
Integer[] candy = new Integer[candyNum];
for(int i = 0; i < candyNum; i++) {
candy[i] = Integer.parseInt(candyStr[i]);
}
Integer[] hunger = new Integer[bearNum];
HashMap<Integer, Integer> map = new HashMap<>();
Integer[] array = new Integer[bearNum];
for(int i =0; i < bearNum; i++) {
String[] bearSingle = bufferedReader.readLine().split(" ");
map.put(Integer.parseInt(bearSingle[0]), i);
array[i] = Integer.parseInt(bearSingle[0]);
hunger[i] = Integer.parseInt(bearSingle[1]);
}
Arrays.sort(array);
Arrays.sort(candy);
Integer[] result = new Integer[bearNum];
for(int i = bearNum - 1; i >= 0; i--) {
Integer pos = map.get(array[i]);
Integer temp = hunger[pos];
Boolean goon = true;
Integer index = candyNum - 1;
while(goon) {
if(index >= 0) {
Integer singleCandy = candy[index];
if(singleCandy != -1) {
if(temp - singleCandy < 0) {
result[pos] = temp;
} else if(temp - singleCandy > 0) {
candy[index] = -1;
temp -= singleCandy;
} else {
result[pos] = 0;
candy[index] = -1;
goon = false;
}
}
index--;
} else {
result[pos] = temp;
goon = false;
}
}
}
for(int j = 0; j < bearNum; j++) {
System.out.println(result[j]);
}
}
}
题目描述
京京和东东是好朋友。东东很喜欢回文。回文是指从前往后读和从后往前读是一样的词语。京京准备给东东一个惊喜,先取定一个字符串s,然后在后面附上0个或者更多个字母形成回文,京京希望这个回文越短越好。请帮助京京计算他能够得到的最短的回文长度。
输入描述:
输入包括一个字符串s,字符串s长度length(1 ≤ length ≤ 50)
输出描述:
输出一个整数,表示牛牛能够得到的最短的回文长度。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
InputStreamReader inputStreamReader = new InputStreamReader(System.in);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
String arg = bufferedReader.readLine();
if(arg.length() == 1) {
System.out.println(1);
return;
}
for(int i = 0; i < arg.length() - 1; i++) {
String rest = arg.substring(i , arg.length());
Integer j = 0;
Boolean ok = true;
while(j <= rest.length() - 1 - j) {
if(rest.charAt(j) != rest.charAt(rest.length() - 1 - j)) {
ok = false;
break;
}
j++;
}
if(ok) {
System.out.println(i + arg.length());
return;
}
}
System.out.println(arg.length() * 2 - 1);
}
}
题目描述
合法的括号匹配序列被定义为:
1. 空串""是合法的括号序列
2. 如果"X"和"Y"是合法的序列,那么"XY"也是一个合法的括号序列
3. 如果"X"是一个合法的序列,那么"(X)"也是一个合法的括号序列
4. 每个合法的括号序列都可以由上面的规则生成
例如"", "()", "()()()", "(()())", "(((())))"都是合法的。 东东现在有一个合法的括号序列s,一次移除操作分为两步:
1. 移除序列s中第一个左括号
2. 移除序列s中任意一个右括号.保证操作之后s还是一个合法的括号序列
东东现在想知道使用上述的移除操作有多少种方案可以把序列s变为空
如果两个方案中有一次移除操作移除的是不同的右括号就认为是不同的方案。
例如: s = "()()()()()",输出1, 因为每次都只能选择被移除的左括号所相邻的右括号.
s = "(((())))",输出24, 第一次有4种情况, 第二次有3种情况, ... ,依次类推, 4 * 3 * 2 * 1 = 24
输入描述:
输入包括一行,一个合法的括号序列s,序列长度length(2 ≤ length ≤ 20).
输出描述:
输出一个整数,表示方案数
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
InputStreamReader inputStreamReader = new InputStreamReader(System.in);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
String arg = bufferedReader.readLine();
Integer result = 1;
Integer temp = 0;
for (int i = 0; i < arg.length(); i++) {
if (arg.charAt(i) == '(') {
temp++;
} else {
result *= temp;
temp--;
}
}
System.out.println(result);
}
}
题目描述
A 国一共发行了几种不同面值的硬币，分别是面值 1 元，2 元，5 元，10 元，20 元，50 元， 100 元。假设每种面值的硬币数量是无限的，现在你想用这些硬币凑出总面值为 n 的硬币， 同时你想让选出的硬币中，不同的面值种类尽可能多;在面值种类尽可能多的情况下，你想 让选择的硬币总数目尽可能多，请问应该怎么选择硬币呢?
输入描述:
第一行包含一个数字?，表示要凑出的面值。1 ≤ ? ≤ 109
输出描述:
输出两个整数，分别表示最多能有多少种类型的硬币以及在类型最多的情况下最多能用上多少枚硬币。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
static Integer[] param = {1, 2, 5, 10, 20, 50, 100};
public static void main(String[] args) throws IOException {
InputStreamReader inputStreamReader = new InputStreamReader(System.in);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
Integer arg = Integer.valueOf(bufferedReader.readLine());
Integer result1 = 0;
Integer result2 = 0;
for(int i = 0; i < param.length; i++) {
arg -= param[i];
if(arg >= 0) {
result1++;
result2++;
} else {
arg += param[i];
break;
}
}
if(arg > 0) {
result2 += arg;
}
System.out.println(result1 + " " + result2);
}
}
扫一扫
827
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
