标题：年龄问题s夫人一向很神秘。这会儿有人问起她的年龄，她想了想说：
"20年前，我丈夫的年龄刚好是我的2倍，而现在他的年龄刚好是我的1.5倍"。你能算出s夫人现在的年龄吗？
注意，需要提交的是一个整数，不要填写任何多余的内容。
答案：40
package The_nine;
public class One {
public static void main(String[] args) {
//年龄问题
for (int i = 0; i < 100; i++) {
int a = i;
int b = i*2;
if (b+20==(a+20)*1.5){
System.out.println(i+20);
}
}
}
}
标题：海盗与金币12名海盗在一个小岛上发现了大量的金币，后统计一共有将近5万枚。
登上小岛是在夜里，天气又不好。由于各种原因，有的海盗偷拿了很多，有的拿了很少。
后来为了“均贫富”，头目提出一个很奇怪的方案：
每名海盗都把自己拿到的金币放在桌上。然后开始一个游戏。
金币最多的海盗要拿出自己的金币来补偿其他人。
补偿的额度为正好使被补偿人的金币数目翻番(即变为原来的2倍)。
游戏要一直进行下去，直到无法完成。
（当金币数最多的不只一个人或最多金币的人持有金币数不够补偿他人的）游戏就这样紧张地进行了，一直进行了12轮，恰好每人都“放血”一次，
更离奇的是，刚好在第12轮后，每个人的金币数居然都相等了！！ 这难道是天意吗？请你计算，游戏开始前，所有海盗的初始金币数目，从小到大排列，中间有一个空格分开。
答案形如：
8 15 29 58 110 ...
当然，这个不是正确答案。注意：
需要提交的是一行空格分开的整数，不要提交任何多余的内容。
分隔符要用一个西文的空格，不要用其它符号（比如逗号，中文符号等）
package The_nine;
public class Two {
public static void main(String[] args) {
//海盗与金币
int []p = new int[12];//12名海盗的钱
//12个海盗分 分完后没人金币数相同 所以金币总数是12的倍数
for (int i = 12; i < 50000; i+=12) {//金币总数
for (int j = 0; j < 12; j++) {
p[j] = i/12;
}
fjb(p,0,i);
}
}
//p 金币数 max 金币最多的人 sum 总金币数
public static void fjb(int []p,int max,int sum){
//如果能够 进行12轮操作 那么这组数就是目标
if (max==12){
for (int a:p){
System.out.print(a+" ");
}
return;
}
//遍历所有海盗
int maxValue = sum;//金币最多人的金币数
for (int i = 0; i < 12; i++) {
//目的是要将max 经过变化变成 本轮金币数 最多的 所以max不需要减少
if (i==max){
continue;//max不进行变化
}else{
//其余人的金币应该是可以整除2的 如果不能就不符合条件
if (p[i]%2!=0){
return;//直接结束 因为已经不符合条件了
}else{
//所有都都除2
p[i]/=2;
maxValue -= p[i];
}
}
}
p[max] = maxValue;
fjb(p,max+1,sum);
}
}
标题：全排列对于某个串，比如：“1234”，求它的所有全排列。
并且要求这些全排列一定要按照字母的升序排列。
对于“1234”，应该输出(一共4!=24行)：
1234
1243
1324
1342
1423
1432
2134
2143
2314
2341
2413
2431
3124
3142
3214
3241
3412
3421
4123
4132
4213
4231
4312
4321下面是实现程序，请仔细分析程序逻辑，并填写划线部分缺少的代码。
// 轮换前k个，再递归处理
import java.util.*;
public class A
{
static void permu(char[] data, int cur){
if(cur==data.length-1){
System.out.println(new String(data));
return;
}
for(int i=cur; i<data.length; i++){
char tmp = data[i];
for(int j=i-1; j>=cur; j--) data[j+1] = data[j];
data[cur] = tmp;permu(data, cur+1);
tmp = data[cur];
__________________________________________ ;
data[i] = tmp;
}
}
static void permu(String x){
permu(x.toCharArray(),0);
}
public static void main(String[] args){
permu("1234");
}
}
请注意：只需要填写划线部分缺少的内容，不要抄写已有的代码或符号。
package The_nine;
import java.util.*;
public class Three
{
static void permu(char[] data, int cur){
if(cur==data.length-1){
System.out.println(new String(data));
return;
}
for(int i=cur; i<data.length; i++){
char tmp = data[i];
for(int j=i-1; j>=cur; j--) data[j+1] = data[j];
data[cur] = tmp;
permu(data, cur+1);
tmp = data[cur];
for(int j=cur; j<=i-1; j++) data[j]=data[j+1] ;
data[i] = tmp;
}
}
static void permu(String x){
permu(x.toCharArray(),0);
}
public static void main(String[] args){
permu("1234");
}
}
标题：约瑟夫环n 个人的编号是 1~n，如果他们依编号按顺时针排成一个圆圈，从编号是1的人开始顺时针报数。
（报数是从1报起）当报到 k 的时候，这个人就退出游戏圈。下一个人重新从1开始报数。
求最后剩下的人的编号。这就是著名的约瑟夫环问题。本题目就是已知 n，k 的情况下，求最后剩下的人的编号。
题目的输入是一行，2个空格分开的整数n, k
要求输出一个整数，表示最后剩下的人的编号。约定：0 < n,k < 1百万
例如输入：
10 3程序应该输出：
4资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
package The_nine;
import java.util.ArrayList;
import java.util.Scanner;
public class Four {
public static int k;
public static ArrayList<Integer> arr;
public static void main(String[] args) {
//约瑟夫环
Scanner sr = new Scanner(System.in);
int n = sr.nextInt();//总人数
arr = new ArrayList<Integer>();
for (int i = 0; i < n; i++) {
arr.add(i+1);
}
k = sr.nextInt();//数到这个数就结束循环
ysf(1,0);
}
//count:当前数的数 ,index: 当前轮到的人的索引
public static void ysf(int count,int index){
//如果只剩一个人了
if (arr.size()==1){
System.out.println(arr.get(0));
return;
}
//如果索引到最后一个人了 那么继续从头开始
if (index == arr.size()){
index=0;
}
//如果数到目标数的话
if (count==k){
arr.remove(index);//移除这个人
//从下一个人 继续从1开始数
ysf(1,index);
}else{
//如果没有数到目标数 就继续数
ysf(count+1,index+1);
}
}
}
标题：交换次数IT产业人才需求节节攀升。业内巨头百度、阿里巴巴、腾讯（简称BAT）在某海滩进行招聘活动。
招聘部门一字排开。由于是自由抢占席位，三大公司的席位随机交错在一起，形如：
ABABTATT，这使得应聘者十分别扭。
于是，管理部门要求招聘方进行必要的交换位置，使得每个集团的席位都挨在一起。即最后形如：
BBAAATTT 这样的形状，当然，也可能是：
AAABBTTT 等。现在，假设每次只能交换2个席位，并且知道现在的席位分布，
你的任务是计算：要使每个集团的招聘席位都挨在一起需要至少进行多少次交换动作。输入是一行n个字符（只含有字母B、A或T），表示现在的席位分布。
输出是一个整数，表示至少交换次数。比如，输入：
TABTABBTTTT程序应该输出：
3再比如，输入：
TTAAABB程序应该输出：
0我们约定，输入字符串的长度n 不大于10万
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
package The_nine;
import javax.print.DocFlavor;
import java.util.ArrayList;
import java.util.Scanner;
public class Five2 {
public static void main(String[] args) {
//交换次数
Scanner sr = new Scanner(System.in);
String str = sr.next();
//首先 求出串中A B C 各自的数量
int countA = 0;
int countB = 0;
int countT = 0;
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i)=='A'){
countA++;
}
if (str.charAt(i)=='B'){
countB++;
}
if (str.charAt(i)=='T'){
countT++;
}
}
char A = 'A';
char B = 'B';
char T = 'T';
ArrayList<Integer> arr = new ArrayList<Integer>(6);
//交换位置后 一共有六种情况
//A B T , A T B, B A T, B T A, T A B, T B A 求出所有交换方案需要的次数 然后最小的那个就是所需的最少次数
//A B T
arr.add(getCount(str,countA,countB,A,B));
//A T B
arr.add(getCount(str,countA,countT,A,T));
//B A T
arr.add(getCount(str,countB,countA,B,A));
//B T A
arr.add(getCount(str,countB,countT,B,T));
//T A B
arr.add(getCount(str,countT,countA,T,A));
//T B A
arr.add(getCount(str,countT,countB,T,B));
int min = arr.get(0);
for (int i:arr){
if (i<min){
min = i;
}
}
// System.out.println(arr);
System.out.println(min);
}
public static int getCount(String str,int countA,int countB,char A,char B){
int count = 0;//一共需要的交换次数
//求出前面A总数个位置中 有多少A （有多少A已经在目标位置了） A的总数-这个数 就得到了需要交换多少次 才能使所有A到达指定位置
count += countA - find(str.substring(0,countA),A);
//求出 将所有B都移到目标位置需要交换几次
count += countB - find(str.substring(countA,countA+countB),B);
// System.out.println(str.substring(0,countA)+" "+str.substring(countA,countA+countB)+" "+count);
//求出 A 的目标位置中 有多少个B 和B的目标位置中有多少A
int c1 = find(str.substring(0,countA),B);
int c2 = find(str.substring(countA,countA+countB),A);
// System.out.println(" "+c1+" "+c2);
//总次数减去其中最小的那个 因为必须得A中有B 的同时B中有A 才可以减去一次 当A B 都到指定位置了 那么C一定在指定位置 此时的count 就是当前方案需要的总次数
count -= Math.min(c1,c2);
return count;
}
public static int find(String a,char b){
int count = 0;
for (int i = 0; i < a.length(); i++) {
if (a.charAt(i)==b){
count++;
}
}
return count;
}
}
标题：自描述序列小明在研究一个序列，叫Golomb自描述序列，不妨将其记作{G(n)}。这个序列有2个很有趣的性质:
1. 对于任意正整数n，n在整个序列中恰好出现G(n)次。
2. 这个序列是不下降的。以下是{G(n)}的前几项：
n 1 2 3 4 5 6 7 8 9 10 11 12 13
G(n) 1 2 2 3 3 4 4 4 5 5 5 6 6给定一个整数n，你能帮小明算出G(n)的值吗？
输入
----
一个整数n。对于30%的数据，1 <= n <= 1000000
对于70%的数据，1 <= n <= 1000000000
对于100%的数据，1 <= n <= 2000000000000000输出
----
一个整数G(n)
【样例输入】
13【样例输出】
6资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
package The_nine;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Scanner;
public class Six {
public static void main(String[] args) {
//自描述序列 范围大的不会...
Scanner sr = new Scanner(System.in);
long a = sr.nextLong();
ArrayList<Long> arr = new ArrayList<Long>();
arr.add((long)1);
arr.add((long)2);
arr.add((long)2);
for (int i = 3; i < a; i++) {
for (int j = 0; j < arr.get(i-1); j++) {
arr.add((long)i);
}
if (arr.size()>=a){
System.out.println(arr.get((int)(a-1)));
return;
}
}
// System.out.println(arr);
}
}
448
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
