emu in blogjava

原来是女娲，我还一直以为是上帝造的人呢。
从现实的角度看，人是进化出来的，我认为从进化这个角度上来看软件设计，会别有一翻风景。

呵呵你没有看清楚我的测试数据，第一项就是线程数啊，也就是模拟的并发访问的用户数。我分别测试了10个，20个，30个，50个和100个并发线程访问的情况，最后一个情况也就是你说的100*100啊。
一般我们配置tomcat的时候连接数也就是设5～20个左右，tomcat也不是很适合用于更高压力的情形（20个线程通常已经足够支撑三位数的同时在线用户了）。虽然jmeter开1000个线程一点问题都没有，但是通常我做的程序不需要面对这么大的压力了。
我只是在比较相同情形下三个不同版本的tomcat的速度而已，我觉得结果已经够说明问题了。

呵呵你没有看清楚我的测试数据，第一项就是线程数啊，也就是模拟的并发访问的用户数。我分别测试了10个，20个，30个，50个和100个并发线程访问的情况，最后一个情况也就是你说的100*100啊。
一般我们配置tomcat的时候连接数也就是设5～20个左右，tomcat也不是很适合用于更高压力的情形（20个线程通常已经足够支撑三位数的同时在线用户了）。
我只是在比较相同情形下三个不同版本的tomcat的速度而已，我觉得结果已经够说明问题了。

呵呵，这只是篇个人的blog而已，你以为作者在写史记还是纂春秋呢？

官方版本的标准类库也是人写的。除非在虚拟机内部提供支持，否则他恐怕也只能做到这样了。

稍微优化了一下。点击这里下载优化后的版本。

因为你没有把文件用一个http服务器发布出来。
xmlhttprequest不能访问本地文件系统，需要建立http连接才可以。

浅显易懂是我写这写文章的一个关键目标。

ACM的高手可能都忙着培训做题去了吧。

日本人的技术也是技术。技术不分国界。科学家可以划分政治阵营，科学不可以。
以前看《果壳中的宇宙》提到苏联科学家的一些荒唐往事，觉得苏联人也太狭隘了，为什么社会主义的科学就一定要比资本主义的好呢。

能做到2^12种状态就好了。我分析的结果是12！种状态阿，比2^12多了十万倍以上。

终于盼到duduwolf来留言了，荣幸荣幸。
我在你的blog上留过言，加过你的msn，几次想要联系你都未能如愿，能否留个有效的联系方式？有不少问题想和你讨论。
我认为肯定是某种js加工工具，但不是混淆器。再简单的混淆器出来的代码也是一塌糊涂的，google用的工具的加工目的仅仅是压缩文件尺寸，并没有刻意的降低可读性。
google的几个应用针对性很强，用AJaH方式显然是非常合适的。我一直想强调的是，我们做系统不可以照抄google的方式，要多在可维护性和通用性上想问题，不要放任系统变的太专用、耦合变的太强、软件变的太“硬”。

从来没有遇到过这个问题，估计是你用了同步方式发送数据造成的，试试改用异步回调方式来解决这个问题。

直接拷贝代码下来不能运行，是因为这一行：
<style>b{position:absolute;cursor:hand;font-size:20}</style>
从上面拷贝下来的时候居然变成：
<style>b{}{position:absolute;cursor:hand;font-size:20}</style>
这是代码展示器的一个bug了，自己改回来就好了。

MFF屏蔽不了。
其实按照原游戏的效果，这些字母都应该是gif图片做的，本来就不存在选中问题。
不过写程序纯粹为了好玩，没花那么多时间来做这些细节，只是随便放些字母上去。

浏览器出于安全考虑限制了来自不同域的页面不能相互访问页面内容，也限制了xmlhttp控件不能访问其他域的xml资源。如果你没有遇到这个问题的话，那么对你可能并不是问题。

冒大哥提到了编码问题，eamoi 前阵子好像也在头疼？
这个问题上我的建议是根本上回避这个问题，否则怎么解决都是很麻烦的事情。

楼上是冒志鸿大哥啊，久仰久仰！

myy:

---

比如，服务端返回：
<ul>
<li>aaa</li>
<li>bbb</li>
<li>ccc</li>
</ul>
这样的数据，很多情况下，放到页面中就可以显示了，如果不符合要求，用xml也能解析重新组织。而不是自己重新定义一套tag

---

我很怀疑你有没有实践经验了。一般情况下我们数据显示到页面上都会带上css样式的，同样的数据的不同的页面上往往都使用不同的样式。
至于再刻意去把xhtml按照xml去解析，完全就失去了xml的“自说明性”的优点了。有一天别人来维护你的代码的时候，怎么猜得出你的数据表达的是这个意思呢：
<userlist>
<user>aaa</user>
<user>bbb</user>
<user>ccc</user>
</userlist>

如果AJAH只适合简单的情况，而AJAX则全都适合，那么为什么要用AJAH呢？

楼上说的是否是 java.net.URLDecoder / java.net.URLEncoder
这两个方法对应的是javascript的 encodeURI/decodeURI 和 encodeURIComponent/decodeURIComponent 吧？
我写的两个方法对应的是javascript 的escape/unescape

转载要忠实，不要夹私货

用动态规划？具体怎么做呢？
cheapwine是judgeonline过来的啊？

这段时间好像问题比较多哦。

我觉得具体的java话题当然很重要，算法和数据结构这样的基础也不可忽略，google code jam这样的赛事blogjava关注的人太少了，所以放到首页上吸引一下眼球而已。如果大家真的不感兴趣就算了，勉强不来的。

又是自己做排序啊?

就是首先生成所有可能的set和run，然后尝试所有run和set的组合，看看那个符合要求啊。

我觉得这组解是干扰数据：

{2,2,2,4,4}
Returns: 2

We can use a 3x2 rectangle and a 2x4 rectangle.



　　　××
　　　××
×××××
×××××


如果题目提供的解是这样：



　　　××
　　　××
×××××
×××××


答案就容易找的多了。

参赛就可以copy题目出来了。

一个钟头要求做这么变态一道题再加一道小题，要求确实高了一点。不知道有多少高手得分？

import java.util.ArrayList;
public class PlayCards {
    public int maxCards(String[] cards){
        //S=0 H=1 D=2 C=3
        int[][] map = new int[11][4];
        for(int i=0;i<cards.length;i++){
            String[] t = cards[i].split(" ");
            int t0 = Integer.parseInt(t[0],10)-1;
            int t1=0;
            if(t[1].equals("H")) t1=1;
                else if(t[1].equals("D")) t1=2;
                else if(t[1].equals("C")) t1=3;
            map[t0][t1]=1;
        }
        /*
        for(int i=0;i<11;i++){
            for(int j=0;j<4;j++)
                System.out.print(map[i][j]+" ");
            System.out.println();
        }
        */
        ArrayList sets = new ArrayList();
        ArrayList set,run;
        for(int i=0;i<11;i++){
            int c = map[i][0]+map[i][1]+map[i][2]+map[i][3];
            if(c==3){
                set = new ArrayList();
                for(int j=0;j<4;j++) if(map[i][j]>0) set.add(new int[]{i,j});
                sets.add(set);
            }else if (c==4){
                set = new ArrayList();
                for(int j=0;j<4;j++) set.add(new int[]{i,j});
                sets.add(set);
                for(int j=0;j<4;j++){
                set = new ArrayList();
                for(int k=0;k<4;k++) if(j!=k) set.add(new int[]{i,k});
                sets.add(set);
                }
            }
        }
        for(int i=0;i<4;i++){
            for(int j=0;j<8;j++){
                for(int k=j;k<11;k++){
                    if(map[k][i]<1) break;
                    if(k-j<2) continue;
                    run = new ArrayList();
                    for(int t=j;t<=k;t++)
                        run.add(new int[]{t,i});
                    sets.add(run);

                }
            }
        }
        int max = 0;
        for(int i=0,n=1<<sets.size();i<n;i++){
            if(checkConflic(sets,i)){
                int m = countCards(sets,i);
                if(max<m) max=m;
            }
        }
        return max;
    }
    private boolean checkConflic(ArrayList sets,int status){
        boolean[][] map = new boolean[11][4];
        for(int i=0,n=sets.size();i<n;i++){
            if((status & (1<<i))==0) continue;
            ArrayList set = (ArrayList)sets.get(i);
            for(int j=0,m=set.size();j<m;j++){
                int[] card = (int[])set.get(j);
                if(map[card[0]][card[1]])return false;
                map[card[0]][card[1]]=true;
            }
        }
        return true;
    }
    private int countCards(ArrayList sets,int status){
        int result =0;
        for(int i=0,n=sets.size();i<n;i++){
            if((status & (1<<i))==0) continue;
            ArrayList set = (ArrayList)sets.get(i);
            result += set.size();
        }
        return result;
    }
    public static void main(String[] args)
    {
        PlayCards p = new PlayCards();
        System.out.println(p.maxCards(new String[]{"1 S", "2 S", "3 S"}));
        System.out.println(p.maxCards(new String[]{"4 C", "4 D", "4 S", "3 S", "2 S"}));
        System.out.println(p.maxCards(new String[]{"1 S", "2 S"}));
        System.out.println(p.maxCards(new String[]{"1 S", "2 S", "10 S", "5 S", "8 S",
                                                     "3 H", "9 H", "6 H", "5 H", "4 H",
                                                     "10 D", "5 D", "7 D", "4 D", "1 D",
                                                     "2 C", "4 C", "5 C", "6 C", "7 C"}
));
    }
}

你的解法倒是很别出心裁，有必要一定要倒过来查吗，正着查不是一样？
不过看看代码量，估计是超过1个小时的。

饭要一口一口吃的，先把数据结构和算法的教科书啃通了再来做吧。

拜托，这是8月份的帖子，讲的是东亚code jam的事了。

今天早上收到的是：

emu,

恭喜您！Google Code Jam - 中国编程挑战赛资格赛的官方结果已经公布。我们很高兴地通知您：您已经晋级第一轮。这是一个很大的成就。

Google? Code Jam –中国编程挑战赛第一轮将于北京时间12月19日星期一晚9点通过网络在线举行。参加第一轮比赛需要注册。注册在比赛当天从北京时间18:00开始到20:55结束。请按如下步骤注册：登录竞技场，点击“Active Contests”（现行比赛）菜单选项，选择“Round One”（第一轮），然后选择“Register”（注册）。

在所有参加第一轮比赛的500名参赛者中，最多250名将会晋级第二轮。第二轮是最后一轮通过网络在线举行的比赛。第二轮比赛将于12月22日星期四举行。

我们建议您在参加第一轮比赛之前阅读竞赛说明。竞赛说明可以在下面网页中找到： http://www.topcoder.com/pl/?module=Static&d1=gccj05&d2=ZH_instructions

此外，请注意我们不久后会再发送一封含有有关第一轮比赛重要信息的后续电子邮件。

再一次恭喜您在资格赛中胜出。

- Google Code Jam 团队

www.topcoder.com, TopCoder, Inc., 703 Hebron Avenue, Glastonbury, CT 06033, 电话：1-866-867-2633

******************************************************

Congratulations! The results of the Google Code Jam China Qualification Round have been officially tabulated and we're happy to announce that you have advanced to Round 1. This is a great accomplishment!

Round 1 of Google(TM) Code Jam China will take place online at 21:00 GMT +8 on Monday, December 19th. Registration is required for this round and will be open from 18:00 to 20:55 GMT +8 on the day of the event. In order to register for the round: Login to the competition arena, click on the "Active Contests" menu item, select Round One, and select "Register".

Of the 500 people participating, up to 250 competitors will advance to Round 2, the final online round, which takes place on Thursday, December 22nd.

We suggest that you read through the instructions prior to competing in Round 1. You can find them here: http://www.topcoder.com/pl/?module=Static&d1=gccj05&d2=EN_instructions

Also, please note that we will follow-up with an additional email shortly, which will include important information regarding Round 1.

Congratulations again on making it through the qualification round!

- The Google Code Jam Team

www.topcoder.com, TopCoder, Inc., 703 Hebron Avenue, Glastonbury, CT 06033, Phone: 1-866-867-2633

这个还真有点不好搞的，我一个钟头搞不定。周末看看有没有时间研究了。

试试更大的测试数据：

public class WordPath {
    public long countPaths(String[] grid, String find){
  int rowCount = grid.length;
  int cellCount=grid[0].length();
  char[][] charGrid = new char[rowCount][cellCount];
  long[][] m = new long[rowCount][cellCount],m1 = new long[rowCount][cellCount];
  for(int y=0;y<rowCount;y++)
   for(int x=0;x<cellCount;x++)
    if (find.charAt(0)==(charGrid[y][x]=grid[y].charAt(x))) m[y][x]=1;
  for(int i=1;i<find.length();i++){
   char ch = find.charAt(i);
   for(int y=0;y<rowCount;y++){
    for(int x=0;x<cellCount;x++){
     if(ch == charGrid[y][x]){
      if(y>0){
       if(x>0)m1[y][x]+=m[y-1][x-1];
       m1[y][x]+=m[y-1][x];
       if(x<cellCount-1) m1[y][x]+=m[y-1][x+1];
      }
      if(x>0)m1[y][x]+=m[y][x-1];
      if(x<cellCount-1) m1[y][x]+=m[y][x+1];
      if(y<rowCount-1){
       if(x>0) m1[y][x]+=m[y+1][x-1];
       m1[y][x]+=m[y+1][x];
       if(x<cellCount-1) m1[y][x]+=m[y+1][x+1];
      }
     }
    }
   }
   m=m1;m1= new long[rowCount][cellCount];
  }
  long result = 0;
  for(int i=0;i<rowCount;i++)for(int j=0;j<cellCount;j++) if(m[i][j]<0||(result += m[i][j])<0)return -1;
  return result;
 }

 public static void main(String[] args){
  WordPath w = new WordPath();
  System.out.println(w.countPaths(new String[]{"ABC","FED","GHI"},"ABCDEFGHI"));
  System.out.println(w.countPaths(new String[]{"ABC","FED","GAI"},"ABCDEA"));
  System.out.println(w.countPaths(new String[]{"ABC","DEF","GHI"},"ABCD"));
  System.out.println(w.countPaths(new String[]{"AA","AA"},"AAAA"));
  System.out.println(w.countPaths(new String[]{"ABABA","BABAB","ABABA","BABAB","ABABA"},"ABABABBA"));
  System.out.println(w.countPaths(new String[]{"AAAAA","AAAAA","AAAAA","AAAAA","AAAAA"},"AAAAAAAAAAA"));
  System.out.println(w.countPaths(new String[]{"AB","CD"},"AA"));
  System.out.println(w.countPaths(new String[]{"AAAAAAAA","AAAAAAAA","AAAAAAAA","AAAAAAAA","AAAAAAAA","AAAAAAAA","AAAAAAAA","AAAAAAAA","AAAAAAAA"},"AAAAAAAAAAAAAAAAAAAA"));
  System.out.println(w.countPaths(new String[]{"AAAAAAAA","AAAAAAAA","AAAAAAAA","AAAAAAAA","AAAAAAAA","AAAAAAAA","AAAAAAAA","AAAAAAAA","AAAAAAAA"},"AAAAAAAAAAAAAAAAAAAAA"));
 }
}

发现一个合二为一的网站，好玩！
http://www.baigoogledu.com/

:) 用动态规划，时间只是随参数大小线性增长的，再慢都很快

就是今年的东亚code jam大赛啊。不过在资格赛就刷下来了，我觉得有点冤的，入围的不见得都是什么高手。模拟题和资格赛题收集在http://www.blogjava.net/emu/category/2769.html

都有人骂起粗话来啦！其实没有必要啦，Brain从小到大参加过多少编程竞赛，你说哪次竞赛没有一点运气的成份在里面呢？14年前我的朋友彭煳在省赛的时候居然在保存结果的时候格式化错了磁盘（当年还是用软盘的），与冠军失之交臂，楼主的遭遇不比他更差吧。13年前地区数学竞赛的时候我最有实力的对手在赛前居然突发麻疹，眼睁睁看我把奖拿了，楼主没他倒霉吧。是金子始终会发光的，彭煳后来去了微软亚洲研究院。
google这次确实准备不足，没有在电信、网通、教育网里面全部架好竞赛平台，对很多选手是很不公平的。不过要是我很重视这个竞赛的话，赛前一定会找找朋友同学家里的线路测试一下哪里比较稳定，提前过去安好开发调试环境，反正有24小时的自由参赛时间，下班后挑个合适的时间特地过去一考一趟就好了。
楼主对 google大赛 还有兴趣的话可以到我的 http://www.blogjava.net/emu/category/2769.html 看看最近两次大赛的题目和解答。后面的几轮要是能弄到题目也会帖出来，也希望看到楼主的解答。
楼主要是真的想挑战难度的话不妨试试： http://www.blogjava.net/emu/articles/10196.html 我还没见到谁解出来了。

>>google在出题上并没有在时间和空间上给予难度。
其实还是会有的。上次东亚我记得是8秒，这次有人说限定是2秒。这个要求对于正确的算法是非常宽松的，但是对于错误的算法就是一个过不去的坎了。象这道题，我第一次的解法就是在时间复杂度上有问题。

上回贴的时候没有做好符号替换，贴出来的代码很多都显示不出来，刚刚才发现。难怪你看了觉得不象动态规划。
递推的过程只需要保留上一步骤的结果和当前计算中的步骤的中间结果就可以了，没有必要用三维数组保存全部推导状态。

我难道不是用动态规划、三重循环吗？

看看，和alphabet是不是一样：

public class WordPath {
    public int countPaths(String[] grid, String find){
        int rowCount = grid.length;
        int cellCount=grid[0].length();
        char[][] charGrid = new char[rowCount][cellCount];
        int[][] m = new int[rowCount][cellCount],m1 = new int[rowCount][cellCount];
        for(int y=0;y<rowCount;y++)
            for(int x=0;x<cellCount;x++)
                if (find.charAt(0)==(charGrid[y][x]=grid[y].charAt(x))) m[y][x]=1;
        for(int i=1;i<find.length();i++){
            char ch = find.charAt(i);
            for(int y=0;y<rowCount;y++){
                for(int x=0;x<cellCount;x++){
                    if(ch == charGrid[y][x]){
                        if(y>0){
                            if(x>0)m1[y][x]+=m[y-1][x-1];
                            m1[y][x]+=m[y-1][x];
                            if(x<cellCount-1) m1[y][x]+=m[y-1][x+1];
                        }
                        if(x>0)m1[y][x]+=m[y][x-1];
                        if(x<cellCount-1) m1[y][x]+=m[y][x+1];
                        if(y<rowCount-1){
                            if(x>0) m1[y][x]+=m[y+1][x-1];
                            m1[y][x]+=m[y+1][x];
                            if(x<cellCount-1) m1[y][x]+=m[y+1][x+1];
                        }
                    }
                }
            }
            m=m1;m1= new int[rowCount][cellCount];
        }
        int result = 0;
        for(int i=0;i<rowCount;i++)for(int j=0;j<cellCount;j++) if((result += m[i][j])>1000000000)return -1;
        return result;
    }

    public static void main(String[] args){
        WordPath w = new WordPath();
        System.out.println(w.countPaths(new String[]{"ABC","FED","GHI"},"ABCDEFGHI"));
        System.out.println(w.countPaths(new String[]{"ABC","FED","GAI"},"ABCDEA"));
        System.out.println(w.countPaths(new String[]{"ABC","DEF","GHI"},"ABCD"));
        System.out.println(w.countPaths(new String[]{"AA","AA"},"AAAA"));
        System.out.println(w.countPaths(new String[]{"ABABA","BABAB","ABABA","BABAB","ABABA"},"ABABABBA"));
        System.out.println(w.countPaths(new String[]{"AAAAA","AAAAA","AAAAA","AAAAA","AAAAA"},"AAAAAAAAAAA"));
        System.out.println(w.countPaths(new String[]{"AB","CD"},"AA"));
    }
}

public class BusStops
{
public int countStops(String[] cityMap, int walkingDistance){
int x=-1,y=-1,result=0;
for(int i=0;i<cityMap.length;i++){
if(cityMap[i].indexOf("X")>-1){
y=i;x=cityMap[i].indexOf("X");
break;
}
}
for(int i=0;i<cityMap.length;i++){
String s = cityMap[i];
for(int j=0;j<s.length();j++){
if(s.charAt(j)=='B'){
int a= Math.abs(y-i)+Math.abs(x-j);
if(a<=walkingDistance) result++;
}
}
}
return result;
}
public static void main(String[] args)
{
BusStops b = new BusStops();
System.out.println(b.countStops( new String[]{"...B.",".....","..X.B",".....","B...."},3));
System.out.println(b.countStops( new String[]{"B.B..",".....","B....",".....","....X"},8));
System.out.println(b.countStops( new String[]{"BBBBB","BB.BB","B.X.B","BB.BB","BBBBB"},1));
System.out.println(b.countStops( new String[]{"B..B..",".B...B","..B...","..B.X.","B.B.B.",".B.B.B"},3));
}
}

public class FillBaskets {
public int countWays(int baskets, int capacity, int balls){
if(balls==0) return 1;
if(baskets == 1)
if (balls<=capacity) return 1; else return 0;
int result = 0;
for(int i=0;i<=capacity&&i<=balls;i++){
result += countWays(baskets-1,capacity,balls-i);
}
return result;
}
}

public class WordPath
{
int resultCount;
public int countPaths(String[] grid, String find){
int rowCount = grid.length;
int cellCount=grid[0].length();
resultCount = 0;
char[][] charGrid = new char[rowCount][cellCount];
for(int y=0;y<rowCount;y++)
for(int x=0;x<cellCount;x++)
charGrid[y][x] = grid[y].charAt(x);
for(int y=0;y<rowCount;y++){
for(int x=0;x<cellCount;x++){
if(charGrid[y][x]==find.charAt(0)){
doCount(charGrid,find.substring(1),x,y);
}
if(resultCount<0) return -1;
}
}
return resultCount;
}
private void doCount(char[][] c,String find,int x,int y){
if(resultCount<0) return;
if(find.length()==0) {
resultCount++;
if(resultCount>10000000) resultCount=-1;
return;
}
if(y>0){
if(c[y-1][x]==find.charAt(0))
doCount(c,find.substring(1),x,y-1);
if(resultCount<0) return ;
if(x>0 && c[y-1][x-1]==find.charAt(0))
doCount(c,find.substring(1),x-1,y-1);
if(resultCount<0) return ;
if(x<c[0].length-1 && c[y-1][x+1]==find.charAt(0))
doCount(c,find.substring(1),x+1,y-1);
}
if(resultCount<0) return ;
if(y<(c.length-1)){
if(c[y+1][x]==find.charAt(0))
doCount(c,find.substring(1),x,y+1);
if(resultCount<0) return ;
if(x>0 && c[y+1][x-1]==find.charAt(0))
doCount(c,find.substring(1),x-1,y+1);
if(resultCount<0) return ;
if(x<c[0].length-1 && c[y+1][x+1]==find.charAt(0))
doCount(c,find.substring(1),x+1,y+1);
}
if(resultCount<0) return ;
if(x>0 && c[y][x-1]==find.charAt(0))
doCount(c,find.substring(1),x-1,y);
if(resultCount<0) return ;
if(x<c[0].length-1 && c[y][x+1]==find.charAt(0)){
doCount(c,find.substring(1),x+1,y);
}
return;
}

public static void main(String[] args){
WordPath w = new WordPath();
System.out.println(w.countPaths(new String[]{"ABC","FED","GHI"},"ABCDEFGHI"));
System.out.println(w.countPaths(new String[]{"ABC","FED","GAI"},"ABCDEA"));
System.out.println(w.countPaths(new String[]{"ABC","DEF","GHI"},"ABCD"));
System.out.println(w.countPaths(new String[]{"AA","AA"},"AAAA"));
System.out.println(w.countPaths(new String[]{"ABABA","BABAB","ABABA","BABAB","ABABA"},"ABABABBA"));
System.out.println(w.countPaths(new String[]{"AAAAA","AAAAA","AAAAA","AAAAA","AAAAA"},"AAAAAAAAAAA"));
System.out.println(w.countPaths(new String[]{"AB","CD"},"AA"));
}
}

时间复杂度太高。当时没有好好想想。和alphabet同出一辙啊！该死！

游戏规则如此，google在全世界都是这样竞赛的，在中国很难开这个例外。
周末有一个大哥跟我说，中国人的问题不是不会变通，是太会变通了。
什么都变通了，还有什么规则可言？
我觉得抱怨归抱怨，游戏规则是一早就定下来了的，还是要遵守。

750分题的时间复杂度降不下来，看来通不过资格赛了，可惜……

小飞侠，应该吧打印结果部分从函数中抽出来。
我的解法是：

public class SongRenamer
{
public String[] rename(String[] artists, String[] albums, String[] tracks, String[] titles, String format){
String[] result = new String[artists.length];
for(int i=0;i<result.length;i++){
result[i] = format
.replaceAll("A","\0\1")
.replaceAll("B","\0\2")
.replaceAll("T","\0\3")
.replaceAll("S","\0\4")
.replaceAll("\0\1",artists[i])
.replaceAll("\0\2",albums[i])
.replaceAll("\0\3",tracks[i])
.replaceAll("\0\4",titles[i]);
}
return result;

}
public static void main(String[] args){
SongRenamer s = new SongRenamer();
String[] result = s.rename(
new String[]{"Marvin Gaye", "Marvin Gaye"},
new String[]{"Here My Dear", "Whats Going On"},
new String[]{"09", "7"},
new String[]{"Annas Song", "Right On"},
"A - B-T-S");
System.out.println(java.util.Arrays.asList(result));

result = s.rename(
new String[]{"The Beatles", "The Supremes", "YellowMatterCustard"},
new String[]{"A Hard Days Night", "A Bit Of Liverpool", "One Night In NYC"},
new String[]{"Twelve", "Siete", "7"},
new String[]{"You Cant Do That", "You Cant Do That", "You Cant Do That"},
"S (S) S");
System.out.println(java.util.Arrays.asList(result));

result = s.rename(
new String[]{" The Leading Spaces"},
new String[]{" "},
new String[]{"Trailing Space "},
new String[]{" s p a c e s "},
"S._A_B(T");
System.out.println(java.util.Arrays.asList(result));

result = s.rename(
new String[] {"Ignored"},
new String[]{"Unnoticed"},
new String[]{"000"},
new String[]{"Uncredited"},
"()-(). ");
System.out.println(java.util.Arrays.asList(result));
}
}