1、小易有一些彩色的砖块。每种颜色由一个大写字母表示。各个颜色砖块看起来都完全一样。现在有一个给定的字符串s,s中每个字符代表小易的某个砖块的颜色。小易想把他所有的砖块排成一行。如果最多存在一对不同颜色的相邻砖块,那么这行砖块就很漂亮的。请你帮助小易计算有多少种方式将他所有砖块排成漂亮的一行。(如果两种方式所对应的砖块颜色序列是相同的,那么认为这两种方式是一样的。)
例如: s = "ABAB",那么小易有六种排列的结果:
"AABB","ABAB","ABBA","BAAB","BABA","BBAA"
其中只有"AABB"和"BBAA"满足最多只有一对不同颜色的相邻砖块。
6、小易将n个棋子摆放在一张无限大的棋盘上。第i个棋子放在第x[i]行y[i]列。同一个格子允许放置多个棋子。每一次操作小易可以把一个棋子拿起并将其移动到原格子的上、下、左、右的任意一个格子中。小易想知道要让棋盘上出现有一个格子中至少有i(1 ≤ i ≤ n)个棋子所需要的最少操作次数.
8、小易非常喜欢拥有以下性质的数列:
1、数列的长度为n
2、数列中的每个数都在1到k之间(包括1和k)
3、对于位置相邻的两个数A和B(A在B前),都满足(A <= B)或(A mod B != 0)(满足其一即可)
例如,当n = 4, k = 7
那么{1,7,7,2},它的长度是4,所有数字也在1到7范围内,并且满足第三条性质,所以小易是喜欢这个数列的
但是小易不喜欢{4,4,4,2}这个数列。小易给出n和k,希望你能帮他求出有多少个是他会喜欢的数列。
例如: s = "ABAB",那么小易有六种排列的结果:
"AABB","ABAB","ABBA","BAAB","BABA","BBAA"
其中只有"AABB"和"BBAA"满足最多只有一对不同颜色的相邻砖块。
输入描述:
输入包括一个字符串s,字符串s的长度length(1 ≤ length ≤ 50),s中的每一个字符都为一个大写字母(A到Z)。
输出描述:
输出一个整数,表示小易可以有多少种方式。
输入例子1:
ABAB
输出例子1:
2
import java.util.HashSet;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String str = in.nextLine();
// 用hashSet记录字符串中有几种字符
HashSet<String> hs = new HashSet<>();
for (int i = 0; i < str.length(); i++) {
hs.add(str.substring(i, i + 1));
// 如果一旦有两种以上的字符就输出0
if (hs.size() > 2) {
System.out.println(0);
return;
}
}
if (hs.size() ==1)
System.out.println(1);
// 有两种字符就输出2，有一种字符就输出1
else if (hs.size() ==2)
System.out.println(2);
}
}2、如果一个数列S满足对于所有的合法的i,都有S[i + 1] = S[i] + d, 这里的d也可以是负数和零,我们就称数列S为等差数列。
小易现在有一个长度为n的数列x,小易想把x变为一个等差数列。小易允许在数列上做交换任意两个位置的数值的操作,并且交换操作允许交换多次。但是有些数列通过交换还是不能变成等差数列,小易需要判别一个数列是否能通过交换操作变成等差数列
1、将a_i放入b序列的末尾
2、逆置b序列
小易需要你计算输出操作n次之后的b序列。
小易现在有一个长度为n的数列x,小易想把x变为一个等差数列。小易允许在数列上做交换任意两个位置的数值的操作,并且交换操作允许交换多次。但是有些数列通过交换还是不能变成等差数列,小易需要判别一个数列是否能通过交换操作变成等差数列
输入描述:
输入包括两行,第一行包含整数n(2 ≤ n ≤ 50),即数列的长度。 第二行n个元素x[i](0 ≤ x[i] ≤ 1000),即数列中的每个整数。
输出描述:
如果可以变成等差数列输出"Possible",否则输出"Impossible"。
输入例子1:
3 3 1 2
输出例子1:
Possible
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while(in.hasNext()) {
int n = in.nextInt();
int[] arr = new int[n];
for(int i = 0; i < n; i++) {
arr[i] = in.nextInt();
}
System.out.println(isEqualDifferenceSeries(arr, n));
}
}
private static String isEqualDifferenceSeries(int[] arr, int n) {
if(n < 2 || n > 50) {
return "Impossible";
}
Arrays.sort(arr);
int diff = arr[1] - arr[0];
for(int i = 2; i < n; i++) {
if(arr[i] - arr[i - 1] != diff) {
return "Impossible";
}
}
return "Possible";
}
}3、如果一个01串任意两个相邻位置的字符都是不一样的,我们就叫这个01串为交错01串。例如: "1","10101","0101010"都是交错01串。
小易现在有一个01串s,小易想找出一个最长的连续子串,并且这个子串是一个交错01串。小易需要你帮帮忙求出最长的这样的子串的长度是多少。
小易现在有一个01串s,小易想找出一个最长的连续子串,并且这个子串是一个交错01串。小易需要你帮帮忙求出最长的这样的子串的长度是多少。
输入描述:
输入包括字符串s,s的长度length(1 ≤ length ≤ 50),字符串中只包含'0'和'1'
输出描述:
输出一个整数,表示最长的满足要求的子串长度。
输入例子1:
111101111
输出例子1:
3
import java.util.Scanner;
public class Main{
public static void main(String []args){
Scanner in=new Scanner(System.in);
while(in.hasNext()){
String str=in.next();
int maxLen=1;
int len=1;
for(int i=1;i<str.length();i++){
if(str.charAt(i)!=str.charAt(i-1)){
len++;
if(len>maxLen){
maxLen=len;
}
}
else
len=1;
}
System.out.println(maxLen);
}
}
}1、将a_i放入b序列的末尾
2、逆置b序列
小易需要你计算输出操作n次之后的b序列。
输入描述:
输入包括两行,第一行包括一个整数n(2 ≤ n ≤ 2*10^5),即序列的长度。 第二行包括n个整数a_i(1 ≤ a_i ≤ 10^9),即序列a中的每个整数,以空格分割。
输出描述:
在一行中输出操作n次之后的b序列,以空格分割,行末无空格。
输入例子1:
4 1 2 3 4
输出例子1:
4 2 1 3
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNextInt()) {
int n = in.nextInt();
int[] nums = new int[n];
for (int i = 0; i < n; i++) {
nums[i] = in.nextInt();
}
for (int i = n - 1; i >= 0; i -= 2) { // 前一半从最后一个数开始以2为步长递减
System.out.print(nums[i] + " ");
}
for (int i = n % 2; i < n - 2; i += 2) { // 后一半根据整数个数的奇偶，分别从第二个或第一个数开始以2为步长递增
System.out.print(nums[i] + " ");
}
System.out.print(nums[n - 2]); // 最后一个数
}
}
}输入描述:
输入包括一行,四个整数x, f, d, p(1 ≤ x,f,d,p ≤ 2 * 10^9),以空格分割
输出描述:
输出一个整数, 表示小易最多能独立生活多少天。
输入例子1:
3 5 100 10
输出例子1:
11
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long x = sc.nextLong();
long f = sc.nextLong();
long d = sc.nextLong();
long p = sc.nextLong();
if (f >= d / x){
System.out.println(d / x);
}else{
System.out.println((d + p * f)/(x + p));
}
}
}6、小易将n个棋子摆放在一张无限大的棋盘上。第i个棋子放在第x[i]行y[i]列。同一个格子允许放置多个棋子。每一次操作小易可以把一个棋子拿起并将其移动到原格子的上、下、左、右的任意一个格子中。小易想知道要让棋盘上出现有一个格子中至少有i(1 ≤ i ≤ n)个棋子所需要的最少操作次数.
输入描述:
输入包括三行,第一行一个整数n(1 ≤ n ≤ 50),表示棋子的个数 第二行为n个棋子的横坐标x[i](1 ≤ x[i] ≤ 10^9) 第三行为n个棋子的纵坐标y[i](1 ≤ y[i] ≤ 10^9)
输出描述:
输出n个整数,第i个表示棋盘上有一个格子至少有i个棋子所需要的操作数,以空格分割。行末无空格 如样例所示: 对于1个棋子: 不需要操作 对于2个棋子: 将前两个棋子放在(1, 1)中 对于3个棋子: 将前三个棋子放在(2, 1)中 对于4个棋子: 将所有棋子都放在(3, 1)中
输入例子1:
4 1 2 4 9 1 1 1 1
输出例子1:
0 1 3 10
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int[]X = new int[n];
int[]Y = new int[n];
for(int i=0;i<n;i++){
X[i] = scan.nextInt();
}
for(int i=0;i<n;i++){
Y[i] = scan.nextInt();
}
int[] res = new int[n];
for(int i=0;i<n;i++){
res[i] = Integer.MAX_VALUE;
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
for(int k=0;k<n;k++){
int[] res2 = new int[n];
for(int l=0;l<n;l++){
res2[l] = Math.abs(X[l]-X[j])+Math.abs(Y[l]-Y[k]);
}
Arrays.sort(res2);
int res3 = 0;
for(int l=0;l<=i;l++){
res3 = res3 + res2[l];
}
res[i] = Math.min(res3, res[i]);
}
}
}
for(int i=0;i<n;i++){
if(i<n-1){
System.out.print(res[i]+" ");
}else{
System.out.print(res[i]);
}
}
}
}7、小易老师是非常严厉的,它会要求所有学生在进入教室前都排成一列,并且他要求学生按照身高不递减的顺序排列。有一次,n个学生在列队的时候,小易老师正好去卫生间了。学生们终于有机会反击了,于是学生们决定来一次疯狂的队列,他们定义一个队列的疯狂值为每对相邻排列学生身高差的绝对值总和。由于按照身高顺序排列的队列的疯狂值是最小的,他们当然决定按照疯狂值最大的顺序来进行列队。现在给出n个学生的身高,请计算出这些学生列队的最大可能的疯狂值。小易老师回来一定会气得半死。
输入描述:
输入包括两行,第一行一个整数n(1 ≤ n ≤ 50),表示学生的人数 第二行为n个整数h[i](1 ≤ h[i] ≤ 1000),表示每个学生的身高
输出描述:
输出一个整数,表示n个学生列队可以获得的最大的疯狂值。 如样例所示: 当队列排列顺序是: 25-10-40-5-25, 身高差绝对值的总和为15+30+35+20=100。 这是最大的疯狂值了。
输入例子1:
5 5 10 25 40 25
输出例子1:
100
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
int n = in.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = in.nextInt();
}
System.out.println(getMaxCrazyValue(arr, n));
}
}
private static int getMaxCrazyValue(int[] arr, int n) {
Arrays.sort(arr);
int[] newArr = new int[n];
int index = 0;
int j = n - 1;
int i = 0;
newArr[index++] = arr[n / 2];
while (i < j) {
newArr[index++] = arr[i++];
if (index != n) {
newArr[index++] = arr[j--];
}
}
int max = 0;
for (int k = 1; k < n; k++) {
max += Math.abs(newArr[k] - newArr[k - 1]);
}
return max;
}
}8、小易非常喜欢拥有以下性质的数列:
1、数列的长度为n
2、数列中的每个数都在1到k之间(包括1和k)
3、对于位置相邻的两个数A和B(A在B前),都满足(A <= B)或(A mod B != 0)(满足其一即可)
例如,当n = 4, k = 7
那么{1,7,7,2},它的长度是4,所有数字也在1到7范围内,并且满足第三条性质,所以小易是喜欢这个数列的
但是小易不喜欢{4,4,4,2}这个数列。小易给出n和k,希望你能帮他求出有多少个是他会喜欢的数列。
输入描述:
输入包括两个整数n和k(1 ≤ n ≤ 10, 1 ≤ k ≤ 10^5)
输出描述:
输出一个整数,即满足要求的数列个数,因为答案可能很大,输出对1,000,000,007取模的结果。
输入例子1:
2 2
输出例子1:
3
import java.util.Scanner;
public class Main {
static final int mod = 1000000007;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int k = scanner.nextInt();
int[][] state = new int[n+1][k+1];
state[0][1] = 1;
for(int i=1; i<=n; i++) {
int sum = 0;
for(int j=1; j<=k; j++) {
sum = (sum + state[i-1][j]) % mod;
}
for(int j=1; j<=k; j++) {
int invalid = 0;
int p = 2;
while(p*j <= k) {
invalid = (invalid + state[i-1][p*j]) % mod;
p++;
}
state[i][j] = (sum - invalid + mod) % mod;
}
}
int sum = 0;
for(int i=1; i<=k; i++) {
sum = (sum + state[n][i]) % mod;
}
System.out.println(sum);
scanner.close();
}
}
扫一扫
896
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
