蓝桥混搭
标题：兴趣小组
package 蓝桥杯省赛;
import java.awt.peer.SystemTrayPeer;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.math.BigInteger;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class A
{
private static Scanner sc;
public static void main(String[] args)throws FileNotFoundException {
Mapmap = new HashMap();
int cnt = 0;
try {
sc = new Scanner(new FileInputStream("C:\\Users\\Administrator\\Desktop\\20190228Java语言混搭\\2\\A.txt"));
while(sc.hasNextLine())
{
String []s = sc.nextLine().split(", ");
int leng = s.length;
for(int i = 0 ; i < s.length; i ++)
map.put(s[i], 1);
}
sc = new Scanner(new FileInputStream("C:\\Users\\Administrator\\Desktop\\20190228Java语言混搭\\2\\B.txt"));
while(sc.hasNextLine())
{
String []t = sc.nextLine().split(", ");
int leng = t.length;
for(int i = 0 ; i < t.length; i ++)
{
if(map.containsKey(t[i]))//如果存在的话?????????
map.put(t[i], 2);
}
}
Mapmap2 = new HashMap();
sc = new Scanner(new FileInputStream("C:\\Users\\Administrator\\Desktop\\20190228Java语言混搭\\2\\C.txt"));
while(sc.hasNextLine())
{
String []g = sc.nextLine().split(", ");
int leng = g.length;
for(int i = 0 ; i < g.length; i ++)
map2.put(g[i], 1);
}
for(String s:map.keySet())
{
if(map.get(s) == 2)
{
if(map2.containsKey(s) == false)
cnt++;
}
}
System.out.println(cnt);
}catch(FileNotFoundException e) {
e.printStackTrace();
}
}
}
标题：9数算式
观察如下的算式：
9213 x 85674 = 789314562
左边的乘数和被乘数正好用到了1~9的所有数字，每个1次。
而乘积恰好也是用到了1~9的所有数字，并且每个1次。
请你借助计算机的强大计算能力，找出满足如上要求的9数算式一共有多少个？
注意：
1. 总数目包含题目给出的那个示例。
2. 乘数和被乘数交换后作为同一方案来看待。
public class A
{
static int cnt = 0;
static int t[] = new int[10];
static void DFS(int a, int cnt1,int one, int b, int cnt2,int two)
{
if(cnt1 + cnt2 == 9)
{
long gg = one * two;
String kk = String.valueOf(gg);
int []b1 = new int [10];
for(int i = 0 ; i < kk.length();i++)
b1[kk.charAt(i) - '0'] = 1;
int ans = 0 ;
for(int i = 1; i <= 9; i ++)
ans += b1[i];
if(ans == 9)
{
cnt ++;
System.out.println(one + " * " + two + "=" + gg);
}
return ;
}
for(int i = 1; i <= 9; i ++)
{
if(t[i] == 0)//这个东西没有被标记
{
if(cnt1 < a)
{
t[i] = 1;//表示这个东西被标记了
DFS(a,cnt1+1,one * 10 + i, b , cnt2, two);
t[i] = 0;
}else
{
t[i] = 1;//表示这个东西被标记了
DFS(a,cnt1,one,b,cnt2 + 1, two * 10 + i);
t[i] = 0;
}
}
}
return ;
}
public static void main(String[] args){
for(int i = 1; i <= 9; i ++) //表示左边的第一个数是有多少个的;
DFS(i,0,0,9-i,0,0);
System.out.println(cnt/2);
}
}
标题： Excel地址
Excel单元格的地址表示很有趣，它使用字母来表示列号。
比如，
A表示第1列，
B表示第2列，
Z表示第26列，
AA表示第27列，
AB表示第28列，
BA表示第53列，
....
当然Excel的最大列号是有限度的，所以转换起来不难。
如果我们想把这种表示法一般化，可以把很大的数字转换为很长的字母序列呢？
本题目既是要求对输入的数字, 输出其对应的Excel地址表示方式。
例如，
输入：
26
则程序应该输出：
Z
再例如，
输入：
2054
则程序应该输出：
BZZ
我们约定，输入的整数范围[1,2147483647]
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
------------------------------
笨笨有话说：
这有点像进制关系，又不完全是。好像末2位是以1当26，末3位是以1当26*26
歪歪有话说：
要是从字母序列转数字还好点，倒过来有点麻烦，不过计算机跑得快啊。
import java.util.Scanner;
public class Main
{
private static Scanner sc = new Scanner(System.in);
public static void main(String[] args)
{
int dd[] = {1,26,676,17576,456976,11881376,308915776};
int num = sc.nextInt();
String s = new String("");
for(int i = 6; i >= 0; i --)
{
if(num / dd[i] > 0)
{
int sum = 0;
for(int j = i - 1; j >= 0; j--)
sum += dd[j]; //这个地方全部走齐了 表示假设至少都能是A就满足
if(sum + num / dd[i] * dd[i] <= num) //这边是能走齐全的
{
char ch = (char)((char)'A'- 1 + num / dd[i]);
s += String.valueOf(ch); //转换了
num = num - num / dd[i] * dd[i];
}else //这边是不能走齐全的
{
if(num / dd[i] >= 2)
{
char ch = (char)((char)'A'- 2 + num / dd[i]);
s += String.valueOf(ch); //转换了
num = num - (num / dd[i] - 1) * dd[i];
}
}
}
}
System.out.println(s);
System.exit(0);
}
}
标题：青蛙跳杯子
X星球的流行宠物是青蛙，一般有两种颜色：白色和黑色。
X星球的居民喜欢把它们放在一排茶杯里，这样可以观察它们跳来跳去。
如下图，有一排杯子，左边的一个是空着的，右边的杯子，每个里边有一只青蛙。
*WWWBBB
其中，W字母表示白色青蛙，B表示黑色青蛙，*表示空杯子。
X星的青蛙很有些癖好，它们只做3个动作之一：
1. 跳到相邻的空杯子里。
2. 隔着1只其它的青蛙（随便什么颜色）跳到空杯子里。
3. 隔着2只其它的青蛙（随便什么颜色）跳到空杯子里。
对于上图的局面，只要1步，就可跳成下图局面：
WWW*BBB
本题的任务就是已知初始局面，询问至少需要几步，才能跳成另一个目标局面。
输入为2行，2个串，表示初始局面和目标局面。
输出要求为一个整数，表示至少需要多少步的青蛙跳。
例如：
输入：
*WWBB
WWBB*
则程序应该输出：
2
再例如，
输入：
WWW*BBB
BBB*WWW
则程序应该输出：
10
我们约定，输入的串的长度不超过15
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
----------------------------
笨笨有话说：
我梦见自己是一棵大树，
青蛙跳跃，
我就发出新的枝条，
春风拂动那第 5 层的新枝,
哦，我已是枝繁叶茂。
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Scanner;
public class Main{
private static Scanner sc = new Scanner(System.in);
static int maxn = Integer.MAX_VALUE;
static int t;
static class node{
int step;
String peo;
node(){}
node(int b,String ch){step = b; peo = ch;}
}
static int BFS(String s1, String s2)//每一个空都可以六只青蛙往里蹦
{
Queuequ = new LinkedList();
qu.add(new node(0,s1));// 这是初始状态
Mapmap = new HashMap();
while(qu.isEmpty() == false)
{
node tt = qu.poll();//获得之后删除
map.put(tt.peo, true);//记录下防止重复扔进队列里面
int pos = 0;
for(int i = 0 ; i < t; i ++)
{
if(tt.peo.charAt(i) == '*')
{
pos = i;
break;
}
}//知道pos的位置了也就是空的位置
for(int j = pos - 3; j <= pos + 3; j ++)
{
if(j != pos && j >= 0 && j < t ) {
StringBuilder ss = new StringBuilder(tt.peo);
ss.replace(pos, pos+1, tt.peo.charAt(j) +"");
ss.replace(j, j+1, '*'+"");//这两个交换
String kk = new String(ss.toString());
if(map.containsKey(kk) == false)
{
map.put(kk, true);
qu.add(new node(tt.step+1,kk));
}
}
}
if(s2.equals(tt.peo))
return tt.step;
}
return 0;
}
public static void main(String[] args){
String d1 = sc.next();
String d2 = sc.next();
t = d1.length();
System.out.println(BFS(d1,d2));
}
}
标题：方格分割
6x6的方格，沿着格子的边线剪开成两部分。
要求这两部分的形状完全相同。
如图：p1.png, p2.png, p3.png 就是可行的分割法。
试计算：
包括这3种分法在内，一共有多少种不同的分割方法。
注意：旋转对称的属于同一种分割法。
请提交该整数，不要填写任何多余的内容或说明文字。
//509
import java.util.Scanner;
public class Main{
static int ans = 0 ;
static int maze[][] = new int [10][10];
public static void main(String[] args){
maze[3][3] = 1;
DFS(3,3);
System.out.println(ans/4);
}
static int dir[][] = {{0,1},{0,-1},{1,0},{-1,0}};
private static void DFS(int x, int y) {
if(x == 0 || y == 0 || x == 6 || y == 6)//边境
{
ans++;
return;
}
for(int i = 0; i <= 3; i ++)
{
int fx = x + dir[i][0];
int fy = y + dir[i][1];
if(fx < 0 || fy < 0 || fx > 6 || fy > 6 ||maze[fx][fy] == 1) continue ;//不在这个块里面
maze[fx][fy] = 1;
maze[6-fx][6-fy] = 1;
DFS(fx,fy);
maze[fx][fy] = 0;
maze[6-fx][6-fy] = 0;
}
}
}
标题：拉马车
小的时候，你玩过纸牌游戏吗？
有一种叫做“拉马车”的游戏，规则很简单，却很吸引小朋友。
其规则简述如下：
假设参加游戏的小朋友是A和B，游戏开始的时候，他们得到的随机的纸牌序列如下：
A方：[K, 8, X, K, A, 2, A, 9, 5, A]
B方：[2, 7, K, 5, J, 5, Q, 6, K, 4]
其中的X表示“10”，我们忽略了纸牌的花色。
从A方开始，A、B双方轮流出牌。
当轮到某一方出牌时，他从自己的纸牌队列的头部拿走一张，放到桌上，并且压在最上面一张纸牌上（如果有的话）。
此例中，游戏过程：
A出K，B出2，A出8，B出7，A出X，此时桌上的序列为：
K,2,8,7,X
当轮到B出牌时，他的牌K与桌上的纸牌序列中的K相同，则把包括K在内的以及两个K之间的纸牌都赢回来，放入自己牌的队尾。注意：为了操作方便，放入牌的顺序是与桌上的顺序相反的。
此时，A、B双方的手里牌为：
A方：[K, A, 2, A, 9, 5, A]
B方：[5, J, 5, Q, 6, K, 4, K, X, 7, 8, 2, K]
赢牌的一方继续出牌。也就是B接着出5，A出K，B出J，A出A，B出5，又赢牌了。
5,K,J,A,5
此时双方手里牌：
A方：[2, A, 9, 5, A]
B方：[Q, 6, K, 4, K, X, 7, 8, 2, K, 5, A, J, K, 5]
注意：更多的时候赢牌的一方并不能把桌上的牌都赢走，而是拿走相同牌点及其中间的部分。但无论如何，都是赢牌的一方继续出牌，有的时候刚一出牌又赢了，也是允许的。
当某一方出掉手里最后一张牌，但无法从桌面上赢取牌时，游戏立即结束。
对于本例的初始手牌情况下，最后A会输掉，而B最后的手里牌为：
9K2A62KAX58K57KJ5
本题的任务就是已知双方初始牌序，计算游戏结束时，赢的一方手里的牌序。当游戏无法结束时，输出-1。
输入为2行，2个串，分别表示A、B双方初始手里的牌序列。
输出为1行，1个串，表示A先出牌，最后赢的一方手里的牌序。
例如，
输入：
96J5A898QA
6278A7Q973
则程序应该输出：
2J9A7QA6Q6889977
再比如，
输入：
25663K6X7448
J88A5KJXX45A
则程序应该输出：
6KAJ458KXAX885XJ645
我们约定，输入的串的长度不超过30
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
----------------------------
笨笨有话说：
不断删除前边的，又要后边添加.... 如果用数组，需要开一个大点的，请佛祖保佑在游戏结束前，不会用到数组的边缘。
歪歪有话说：
反正串也不长，不如每次操作都返回一个新的串。
默默有话说：
我一般都不吱声，这是典型的队列结构，动态数组最好，没有？自己造一个呗！
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Stack;
public class Main {
private static Scanner sc = new Scanner(System.in);
public static void main(String[] args){
String a = sc.next();
String b = sc.next();
String c = new String();//表示这些是剩下的部分
Game(a,b,c);
}
private static void Game(String a, String b, String c) {
Stack st = new Stack();
boolean flag = true; //表示此刻是由A开始出牌的
Mapmap = new HashMap();
Mapmp1 = new HashMap();
Mapmp2 = new HashMap();
while(a.length() != 0 && b.length() != 0)
{
while(a.length() != 0 && b.length() != 0)
{
if(flag)
{
String x = a.substring(0, 1); //提取首部
a = a.substring(1); //剩下的部分
int k = Check(x,st);//判断是够有无赢牌的可能
st.push(x);
if(k == 1)//表示赢牌了
{
a += st.pop();
while(!st.peek().equals(x))
a += st.pop();
a += st.pop();
break; //只要有赢牌就打破这次
}
if(a.length() == 0)
{
System.out.println(b);
System.exit(0);
}
x = b.substring(0, 1); //提取首部
b = b.substring(1); //剩下的部分
k = Check(x,st);//判断是够有无赢牌的可能
st.push(x);
if(k == 1)//表示赢牌了
{
b += st.pop();
while(!st.peek().equals(x))
b += st.pop();
b += st.pop();
flag = false;
break; //只要有赢牌就打破这次
}
}else //就是由b先开始的
{
String x = b.substring(0, 1); //提取首部
b = b.substring(1); //剩下的部分
int k = Check(x,st);//判断是够有无赢牌的可能
st.push(x);
if(k == 1)//表示赢牌了
{
b += st.pop();
while(!st.peek().equals(x))
b += st.pop();
b += st.pop();
break; //只要有赢牌就打破这次
}
if(b.length() == 0)
{
System.out.println(a);
System.exit(0);
}
x = a.substring(0, 1); //提取首部
a = a.substring(1); //剩下的部分
k = Check(x,st);//判断是够有无赢牌的可能
st.push(x);
if(k == 1)//表示赢牌了
{
a += st.pop();
while(!st.peek().equals(x))
a += st.pop();
a += st.pop();
flag = true;
break; //只要有赢牌就打破这次
}
}
}
String gg = c; //当前局面
if(map.containsKey(a) && map.get(a).equals(b) &&
(( mp1.containsKey(gg) && mp1.get(gg) == -1)||( mp2.containsKey(gg) && mp2.get(gg) == 1) ))
{
System.out.println(-1);
System.exit(0);
}else
{
map.put(a, b);
if(flag) //A先下就是true
mp1.put(gg, -1);
else
mp2.put(gg, 1);
}
}
if(a.length() == 0)
System.out.println(b);
else if(b.length() == 0)
System.out.println(a);
System.exit(0);
}
private static int Check(String x, Stack st) {
if(st.search(x) < 0) //表示找不到
return 0;
else
return 1;
}
}