jellyfish http://jellyfish.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 Caches jellyfish 作者: jellyfish  链接：http://jellyfish.javaeye.com/blog/100840  发表时间: 2007年07月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Distributed Caches:
http://www.danga.com/memcached/
Tangosol - distributed, commercial
JBoss cache
gemstone
swarm
bamboo

Local Caches:
oscache
ehcache
jcs
jcache

Cache API abstraction:
get(key)
put(key, value)
lock(key) - this is used for loading once: first one coming in does the loading, others waits until the first one is done.

Integration:
1. Cache concern should be sealed in AOP or a decorator, should be separated from the normal data loading.

2. Distributed caches should have a remote/JMS interface to refresh/flush data

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Fri, 13 Jul 2007 21:56:15 +0800 http://jellyfish.javaeye.com/blog/100840 http://jellyfish.javaeye.com/blog/100840 General Computing jellyfish 作者: jellyfish  链接：http://jellyfish.javaeye.com/blog/100632  发表时间: 2007年07月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Language:
http://caml.inria.fr/index.en.html
http://www.r-project.org/

Testing:
http://www-128.ibm.com/developerworks/java/library/j-cwt02095/ - Java coverage

AOP:
https://dynaop.dev.java.net/

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Fri, 13 Jul 2007 08:33:46 +0800 http://jellyfish.javaeye.com/blog/100632 http://jellyfish.javaeye.com/blog/100632 ORM links jellyfish 作者: jellyfish  链接：http://jellyfish.javaeye.com/blog/100630  发表时间: 2007年07月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

http://orm.net/overview.html
http://www.objectrolemodeling.com/Home/tabid/1/Default.aspx

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Fri, 13 Jul 2007 08:21:39 +0800 http://jellyfish.javaeye.com/blog/100630 http://jellyfish.javaeye.com/blog/100630 Spring links jellyfish 作者: jellyfish  链接：http://jellyfish.javaeye.com/blog/100629  发表时间: 2007年07月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

http://blog.springframework.com/rob/archives/2005/12/17/tse-slides-for-advanced-mvc-scheduling-and-jmx-presentations/

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Fri, 13 Jul 2007 08:11:45 +0800 http://jellyfish.javaeye.com/blog/100629 http://jellyfish.javaeye.com/blog/100629 JSE links jellyfish 作者: jellyfish  链接：http://jellyfish.javaeye.com/blog/100628  发表时间: 2007年07月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Tutorials:
http://javaboutique.internet.com/tutorials/

memory leak:
http://weblogs.java.net/blog/timboudreau/archive/2005/04/writing_memory.html
http://www.technocage.com/~ray/talks/swing.html

Misc:
http://www.java2s.com/Code/Java/Language-Basics/ObjectInspector.htm
http://www.java2s.com/Code/Java/Language-Basics/UsesreflectionandJavaBeansintrospectionto.htm

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Fri, 13 Jul 2007 08:09:21 +0800 http://jellyfish.javaeye.com/blog/100628 http://jellyfish.javaeye.com/blog/100628 CEP jellyfish 作者: jellyfish  链接：http://jellyfish.javaeye.com/blog/100034  发表时间: 2007年07月11日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

http://www.eventstreamprocessing.com/cep-history.htm
http://www.infoq.com/news/2007/07/EDA-SOA

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Wed, 11 Jul 2007 02:54:19 +0800 http://jellyfish.javaeye.com/blog/100034 http://jellyfish.javaeye.com/blog/100034 Windows jellyfish 作者: jellyfish  链接：http://jellyfish.javaeye.com/blog/100033  发表时间: 2007年07月11日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

http://virt-dimension.sourceforge.net/ - virtual desktop

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Wed, 11 Jul 2007 02:52:35 +0800 http://jellyfish.javaeye.com/blog/100033 http://jellyfish.javaeye.com/blog/100033 Mathematics Links jellyfish 作者: jellyfish  链接：http://jellyfish.javaeye.com/blog/99968  发表时间: 2007年07月11日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Probabilities and Statistics:
http://www.ability.org/probstat.html
http://www.math.ucla.edu/~tom/
http://www.jdawiseman.com/index.html
http://www.jdawiseman.com/papers/easymath/coin-stopping.html(optimal stopping theory)

General:
http://episte.math.ntu.edu.tw/

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Wed, 11 Jul 2007 02:40:26 +0800 http://jellyfish.javaeye.com/blog/99968 http://jellyfish.javaeye.com/blog/99968 interview questions and riddles sites jellyfish 作者: jellyfish  链接：http://jellyfish.javaeye.com/blog/98790  发表时间: 2007年07月07日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

http://www.ocf.berkeley.edu/~wwu/cgi-bin/yabb/YaBB.cgi
http://www.qbyte.org/puzzles/puzzle02.html
http://www.msri.org/communications/emissary/

http://www.mitbbs.com/bbsann/scitech.faq
http://www.geekinterview.com/Interview-Questions

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Sat, 07 Jul 2007 06:35:52 +0800 http://jellyfish.javaeye.com/blog/98790 http://jellyfish.javaeye.com/blog/98790 Financial Data jellyfish 作者: jellyfish  链接：http://jellyfish.javaeye.com/blog/98788  发表时间: 2007年07月07日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

http://www.bloomberg.com

Bond:
http://www.nasdbondinfo.com/asp/bond_search.asp
http://www.investinginbonds.com/marketataglance.asp?catid=34
http://www.treasurydirect.gov/indiv/products/products.htm

Rating:
http://www.fitchratings.com/corporate/sectors/special_reports.cfm?sector_flag=1&marketsector=6&body_content=research

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Sat, 07 Jul 2007 06:28:14 +0800 http://jellyfish.javaeye.com/blog/98788 http://jellyfish.javaeye.com/blog/98788 Spring Batch and other uncharted water jellyfish 作者: jellyfish  链接：http://jellyfish.javaeye.com/blog/80162  发表时间: 2007年05月15日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Spring's new module - Spring Batch, a much needed module.

Besides the usual web container, ejb container, there are other ways to deploy apps. Batch, Grid, and JMS, besides a simple main() or an ANT task, are other common options. There are several concerns together, one is the deployment, another is the messaging, and the third one, not the last one, is the error handling.

  • Deployment: There are just so much similarities in batches, and yet, not until now, someone takes the charge on abstracting this out to a container. Good job, Spring. Even just the batch abstraction is surely a big improvement. If Spring guys can unite the front with GRID, it's even better.
  • Messaging: Most of the batch processes have a different way to communicate with callers, could be an asynchronous call, could leave the results in a file, than ordinary API calls. However, from the caller's perspective, it's just a plain call - get the result. This is common for all messagings. How can we abstract the common behaviors? What are they specifically?
  • Error handling: I personally think this is the hardest part because JDK lacks of support on this. The basic scenario is that in certain cases when errors happen, the batch should record the errors somewhere and keeps going. A twist is how we could propagate the record errors  in different threads.

Spring 2.1 is near.

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Tue, 15 May 2007 21:13:11 +0800 http://jellyfish.javaeye.com/blog/80162 http://jellyfish.javaeye.com/blog/80162 Spring ProxyFactoryBean jellyfish 作者: jellyfish  链接：http://jellyfish.javaeye.com/blog/76611  发表时间: 2007年05月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

There are several discussion about swapping objects during runtime. For example, we may have a case where we need to swap databases depending on the configuration settings or runtime variables, such as user info.

For database related, Spring 2.0 added two classes to short-circuit this case, AbstractRoutingDataSource and its subclass. These two classes are suitable when the choices of swappables are known and listable,  i.e., not based on some formula to deduct the  URL.  The references are:

http://blog.interface21.com/main/2007/01/23/dynamic-datasource-routing/

A more general approach using ProxyfactoryBean is discussed in here:

http://blog.arendsen.net/index.php/2005/07/06/spring-instance-management-part-i-pooling/
http://blog.arendsen.net/index.php/2005/07/06/spring-instance-management-part-ii-pooling/

Recently, I have a case in the distributed computing. I have an ejb-based app which has quite a few ejb services running on different machines. The ejb services are located through a standard service locator. If a service A needs another service B, then A has a piece of code using the locator to find B. This piece of code is pretty ugly because:
1. It results about several hundreds on references on the service locator, which is a singleton, like a wild running cat herd.
2. I can't mock service B for testing.
3. The error handling is wild too.

A better solution is to let A depend on B's interface and inject B from somewhere. we could use Spring's SimpleRemoteStatelessSessionProxyFactoryBean class, however, we have a problem with this. The servers where B is setting on are not fixed, we may move the clusters for several reasons. So even Spring's class is out, with the failover feature, which works only on the fixed cluster. This means the setter during startup time sets something that could be expired and can't be used later on. We have to use the service locator to look for B right before we trigger B's method, i.e., we need a real-time setter.

Another problem, we could refresh the service location settings in real-time. Spring is a little bit hard to do this. So I decide to reuse this.

Spring ProxyFactoryBean can be used for runtime configurations:

1. Switch DataSource depending on the runtime user
2. Delay calling setters which works in real time.

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Sun, 13 May 2007 05:35:00 +0800 http://jellyfish.javaeye.com/blog/76611 http://jellyfish.javaeye.com/blog/76611 Another Google question - drop glassballs from a building 5 jellyfish 作者: jellyfish  链接：http://jellyfish.javaeye.com/blog/79190  发表时间: 2007年05月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Here are some results are the testcases:

1. PathFindTest.test4Ball100Floors():
The result is like this:

path=(f=56, b=3, whole, tried)-->(f=91, b=3, broken, tried)-->(f=71, b=2, broken, tried)-->(f=61, b=1, whole, tried)-->(f=65, b=1, whole, tried)-->(f=68, b=1, whole, tried)-->(f=70, b=1, broken, tried)-->(f=69, b=0, whole, tried)-->END
number of trials=8

The last one has the status "whole", so we have to go back to the first trial with "broken" status, which is the one before last, and it has floor 70.

2. PathFindTest.test1BallSingleCase()
Th result is like this:

path=(f=1, b=0, whole, tried)-->(f=2, b=0, whole, tried)-->(f=3, b=0, whole, tried)-->(f=4, b=0, whole, tried)-->(f=5, b=0, whole, tried)-->(f=6, b=0, whole, tried)-->(f=7, b=0, whole, tried)-->(f=8, b=0, whole, tried)-->(f=9, b=0, whole, tried)-->(f=10, b=0, broken, deducted)-->END
number of trials=9

The last one has the "deducted" flag, this means this element will be excluded from the size of the path since it's a logic deduction, no real trial happened.

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Sun, 13 May 2007 04:01:02 +0800 http://jellyfish.javaeye.com/blog/79190 http://jellyfish.javaeye.com/blog/79190 Another Google question - drop glassballs from a building 4 jellyfish 作者: jellyfish  链接：http://jellyfish.javaeye.com/blog/79189  发表时间: 2007年05月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

The test cases are divided into 3 classes.

The first one is just a pinpoint test class that contains some corner cases:

java 代码
 
  1. package glassball;  
  2.   
  3. import junit.framework.TestCase;  
  4. import java.util.List;  
  5.   
  6. /** 
  7.  * Testcases for path. 
  8.  */  
  9. public class PathFinderTest extends TestCase  
  10. {  
  11.     public void test1BallSingleCase()  
  12.     {  
  13.         int broken = 10;  
  14.         Building building = new Building(10, broken);  
  15.         PathFinder finder = new PathFinder(building, 1);  
  16.         List path = finder.findPuzzlePath();  
  17.         TestUtil.printPath(path);  
  18.         assertTrue(broken == TestUtil.getBrokenFloor(path));  
  19.         assertTrue(TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  20.     }  
  21.   
  22.     public void test2BallSingleCase1()  
  23.     {  
  24.         // 70 is the beginning of the 2nd level search  
  25.         int broken = 70;  
  26.         Building building = new Building(100, broken);  
  27.         PathFinder finder = new PathFinder(building, 2);  
  28.         List path = finder.findPuzzlePath();  
  29.         TestUtil.printPath(path);  
  30.         assertTrue(broken == TestUtil.getBrokenFloor(path));  
  31.         assertTrue(TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  32.     }  
  33.   
  34.     public void test2BallSingleCase2()  
  35.     {  
  36.         // 77 is the end of the 2nd level search.  
  37.         // 77 jumps out of the loop without going to return line.  
  38.         int broken = 77;  
  39.         Building building = new Building(100, broken);  
  40.         PathFinder finder = new PathFinder(building, 2);  
  41.         List path = finder.findPuzzlePath();  
  42.         TestUtil.printPath(path);  
  43.         assertTrue(broken == TestUtil.getBrokenFloor(path));  
  44.         assertTrue(TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  45.     }  
  46.   
  47.     public void test3BallSingleCase()  
  48.     {  
  49.         int broken = 53;  
  50.         Building building = new Building(100, broken);  
  51.         PathFinder finder = new PathFinder(building, 3);  
  52.         List path = finder.findPuzzlePath();  
  53.         TestUtil.printPath(path);  
  54.         assertTrue(broken == TestUtil.getBrokenFloor(path));  
  55.         assertTrue(TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  56.     }  
  57.   
  58.     public void test4BallSingleCase()  
  59.     {  
  60.         // 89 is a special number to test whether  
  61.         // totalFloors == baseFloor + totalFloors, it caused  
  62.         // 91 has been hit 3 times. Without this check, it kills 3 balls.  
  63.         int broken = 89;  
  64.         Building building = new Building(100, broken);  
  65.         PathFinder finder = new PathFinder(building, 4);  
  66.         List path = finder.findPuzzlePath();  
  67.         TestUtil.printPath(path);  
  68.         assertTrue(broken == TestUtil.getBrokenFloor(path));  
  69.         assertTrue(TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  70.     }  
  71.   
  72.     public void test4BallForLowerBound1()  
  73.     {  
  74.         int broken = 1;  
  75.         Building building = new Building(10, broken);  
  76.         PathFinder finder = new PathFinder(building, 4);  
  77.         List path = finder.findPuzzlePath();  
  78.         TestUtil.printPath(path);  
  79.         assertTrue(broken == TestUtil.getBrokenFloor(path));  
  80.         assertTrue(TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  81.     }  
  82.   
  83.     public void test4BallForLowerBound2()  
  84.     {  
  85.         int broken = 2;  
  86.         Building building = new Building(10, broken);  
  87.         PathFinder finder = new PathFinder(building, 4);  
  88.         List path = finder.findPuzzlePath();  
  89.         TestUtil.printPath(path);  
  90.         assertTrue(broken == TestUtil.getBrokenFloor(path));  
  91.         assertTrue(TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  92.     }  
  93.   
  94.     public void test4BallForLowerBound3()  
  95.     {  
  96.         int broken = 6;  
  97.         Building building = new Building(10, broken);  
  98.         PathFinder finder = new PathFinder(building, 4);  
  99.         List path = finder.findPuzzlePath();  
  100.         TestUtil.printPath(path);  
  101.         assertTrue(broken == TestUtil.getBrokenFloor(path));  
  102.         assertTrue(TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  103.     }  
  104.   
  105.     public void test2Ball4Floors()  
  106.     {  
  107.         int broken = 1;  
  108.         Building building = new Building(4, broken);  
  109.         PathFinder finder = new PathFinder(building, 2);  
  110.         List path = finder.findPuzzlePath();  
  111.         TestUtil.printPath(path);  
  112.         assertTrue(broken == TestUtil.getBrokenFloor(path));  
  113.         assertTrue(TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  114.     }  
  115.   
  116.     public void test3Ball17Floors()  
  117.     {  
  118.         int broken = 13;  
  119.         Building building = new Building(17, broken);  
  120.         PathFinder finder = new PathFinder(building, 3);  
  121.         List path = finder.findPuzzlePath();  
  122.         TestUtil.printPath(path);  
  123.         assertTrue(broken == TestUtil.getBrokenFloor(path));  
  124.         assertTrue(TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  125.     }  
  126.   
  127.     public void test4Ball100Floors()  
  128.     {  
  129.         int broken = 70;  
  130.         Building building = new Building(100, broken);  
  131.         PathFinder finder = new PathFinder(building, 4);  
  132.         List path = finder.findPuzzlePath();  
  133.         TestUtil.printPath(path);  
  134.         assertTrue(broken == TestUtil.getBrokenFloor(path));  
  135.         assertTrue(TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  136.     }  
  137.   
  138.     public void test5Ball100Floors()  
  139.     {  
  140.         int broken = 70;  
  141.         Building building = new Building(100, broken);  
  142.         PathFinder finder = new PathFinder(building, 5);  
  143.         List path = finder.findPuzzlePath();  
  144.         TestUtil.printPath(path);  
  145.         assertTrue(broken == TestUtil.getBrokenFloor(path));  
  146.         assertTrue(TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  147.     }  
  148.   
  149.     public void test6Ball100Floors()  
  150.     {  
  151.         int broken = 70;  
  152.         Building building = new Building(100, broken);  
  153.         PathFinder finder = new PathFinder(building, 6);  
  154.         List path = finder.findPuzzlePath();  
  155.         TestUtil.printPath(path);  
  156.         assertTrue(broken == TestUtil.getBrokenFloor(path));  
  157.         assertTrue(TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  158.     }  
  159.   
  160.     public void test3Ball9Floors()  
  161.     {  
  162.         int broken = 9;  
  163.         Building building = new Building(100, broken);  
  164.         PathFinder finder = new PathFinder(building, 3);  
  165.         List path = finder.findPuzzlePath();  
  166.         TestUtil.printPath(path);  
  167.         assertTrue(broken == TestUtil.getBrokenFloor(path));  
  168.         assertTrue(TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  169.     }  
  170. }  

The util class is like this:

java 代码
 
  1. package glassball;  
  2.   
  3. import java.util.List;  
  4.   
  5. /** 
  6.  * 
  7.  */  
  8. public class TestUtil  
  9. {  
  10.     public static void printPath(List path)  
  11.     {  
  12.         System.out.print("path=");  
  13.         for (int i=0; i<path.size(); i++)  
  14.         {  
  15.             System.out.print(path.get(i).toString() + "-->");  
  16.         }  
  17.         System.out.println("END");  
  18.         System.out.println("number of trials=" + path.size());  
  19.     }  
  20.   
  21.     public static int getPathSize(List path)  
  22.     {  
  23.         int size = 0;  
  24.         for (int i=0; i<path.size(); i++)  
  25.         {  
  26.             Trial trial = (Trial)path.get(i);  
  27.             if (!trial.isDeducted()) size++;  
  28.         }  
  29.   
  30.         return size;  
  31.     }  
  32.       
  33.     public static int getBrokenFloor(List path)  
  34.     {  
  35.         // several cases:  
  36.         // 1. the last one is broken,  
  37.         // 2. the last broken is before several wholes.  
  38.         // 3. all are broken, the one we are looking for is not in the list because:  
  39.         //     it's the last one.  
  40.         for (int i=path.size()-1; i>=0; i--)  
  41.         {  
  42.             Trial trial = (Trial)path.get(i);  
  43.             // The last broken piece is the one we are looking for.  
  44.             if (trial.isBroken()) return trial.getFloor();  
  45.         }  
  46.         return -1;  
  47.     }  
  48.   
  49.     public static boolean compareTwoIntegerArrays(List path1, List path2)  
  50.     {  
  51.         if (path1.size() != path2.size()) return false;  
  52.   
  53.         for (int i=0; i<path1.size(); i++)  
  54.         {  
  55.             if (path1.get(i).equals(path2.get(i))) return false;  
  56.         }  
  57.   
  58.         return true;  
  59.     }  
  60. }  


The second one is to vary the broken level to see whether it's good enough:

java 代码
 
  1. package glassball;  
  2.   
  3. import junit.framework.TestCase;  
  4.   
  5. import java.util.List;  
  6.   
  7. /** 
  8.  * This is to test the minimal trial numbers. 
  9.  */  
  10. public class PathFinderMinimalFullTest extends TestCase  
  11. {  
  12.     public void test3Ball100Floors()  
  13.     {  
  14.         int numOfTrials = 0;  
  15.   
  16.         for (int broken=1; broken < 100; broken++)  
  17.         {  
  18.             Building building = new Building(100, broken);  
  19.             PathFinder finder = new PathFinder(building, 3);  
  20.             List path = finder.findPuzzlePath();  
  21.   
  22.             if (TestUtil.getPathSize(path) > numOfTrials)  
  23.                 numOfTrials = TestUtil.getPathSize(path);  
  24.   
  25.             TestUtil.printPath(path);  
  26.             assertTrue(broken == TestUtil.getBrokenFloor(path));  
  27.             assertTrue(TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  28.         }  
  29.   
  30.         System.out.println("numOfTrials=" + numOfTrials);  
  31.     }  
  32.   
  33.     public void test4Ball100Floors()  
  34.     {  
  35.         int numOfTrials = 0;  
  36.   
  37.         for (int broken=1; broken < 100; broken++)  
  38.         {  
  39.             Building building = new Building(100, broken);  
  40.             PathFinder finder = new PathFinder(building, 4);  
  41.             List path = finder.findPuzzlePath();  
  42.   
  43.             if (TestUtil.getPathSize(path) > numOfTrials)  
  44.                 numOfTrials = TestUtil.getPathSize(path);  
  45.   
  46.             TestUtil.printPath(path);  
  47.             assertTrue(broken == TestUtil.getBrokenFloor(path));  
  48.             assertTrue(TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  49.         }  
  50.   
  51.         System.out.println("numOfTrials=" + numOfTrials);  
  52.     }  
  53.   
  54.     public void test5Ball100Floors()  
  55.     {  
  56.         int numOfTrials = 0;  
  57.   
  58.         for (int broken=1; broken < 100; broken++)  
  59.         {  
  60.             Building building = new Building(100, broken);  
  61.             PathFinder finder = new PathFinder(building, 5);  
  62.             List path = finder.findPuzzlePath();  
  63.   
  64.             if (TestUtil.getPathSize(path) > numOfTrials)  
  65.                 numOfTrials = TestUtil.getPathSize(path);  
  66.   
  67.             TestUtil.printPath(path);  
  68.             assertTrue(broken == TestUtil.getBrokenFloor(path));  
  69.             assertTrue(TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  70.         }  
  71.   
  72.         System.out.println("numOfTrials=" + numOfTrials);  
  73.     }  
  74.   
  75.     public void test5Ball1000Floors()  
  76.     {  
  77.         int numOfTrials = 0;  
  78.   
  79.         for (int broken=1; broken < 200; broken++)  
  80.         {  
  81.             Building building = new Building(200, broken);  
  82.             PathFinder finder = new PathFinder(building, 5);  
  83.             List path = finder.findPuzzlePath();  
  84.   
  85.             if (TestUtil.getPathSize(path) > numOfTrials)  
  86.                 numOfTrials = TestUtil.getPathSize(path);  
  87.   
  88.             TestUtil.printPath(path);  
  89.             assertTrue(broken == TestUtil.getBrokenFloor(path));  
  90.             assertTrue(TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  91.         }  
  92.   
  93.         System.out.println("numOfTrials=" + numOfTrials);  
  94.     }  
  95.   
  96.     public void test6Ball1000Floors()  
  97.     {  
  98.         int numOfTrials = 0;  
  99.   
  100.         for (int broken=1; broken < 200; broken++)  
  101.         {  
  102.             Building building = new Building(200, broken);  
  103.             PathFinder finder = new PathFinder(building, 6);  
  104.             List path = finder.findPuzzlePath();  
  105.   
  106.             if (TestUtil.getPathSize(path) > numOfTrials)  
  107.                 numOfTrials = TestUtil.getPathSize(path);  
  108.   
  109.             TestUtil.printPath(path);  
  110.             assertTrue(broken == TestUtil.getBrokenFloor(path));  
  111.             assertTrue(TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  112.         }  
  113.   
  114.         System.out.println("numOfTrials=" + numOfTrials);  
  115.     }  
  116.   
  117.     public void test10Ball1000Floors()  
  118.     {  
  119.         int numOfTrials = 0;  
  120.   
  121.         for (int broken=1; broken < 200; broken++)  
  122.         {  
  123.             Building building = new Building(200, broken);  
  124.             PathFinder finder = new PathFinder(building, 50);  
  125.             List path = finder.findPuzzlePath();  
  126.   
  127.             if (TestUtil.getPathSize(path) > numOfTrials)  
  128.                 numOfTrials = TestUtil.getPathSize(path);  
  129.   
  130.             TestUtil.printPath(path);  
  131.             assertTrue(broken == TestUtil.getBrokenFloor(path));  
  132.             assertTrue(TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  133.         }  
  134.   
  135.         System.out.println("numOfTrials=" + numOfTrials);  
  136.     }  
  137. }  

The third one is a brutal force testing to test all cases in a certain range:

java 代码
 
  1. package glassball;  
  2.   
  3. import junit.framework.TestCase;  
  4.   
  5. import java.util.List;  
  6.   
  7. /** 
  8.  * The brutal force loops. 
  9.  */  
  10. public class PathFinderFullTest extends TestCase  
  11. {  
  12.     public void test1BallSingleCase()  
  13.     {  
  14.         for (int floors=3; floors<=300; floors++)  
  15.         {  
  16.             for (int broken=1; broken<floors; broken++)  
  17.             {  
  18.                 for (int balls=1; balls<6; balls++)  
  19.                 {  
  20.                     Building building = new Building(floors, broken);  
  21.                     PathFinder finder = new PathFinder(building, balls);  
  22.                     List path = finder.findPuzzlePath();  
  23.   
  24.                     //TestUtil.printPath(path);  
  25.                     String errorMsg = "floors=" + floors + " broken=" + broken + " balls=" + balls;  
  26.                     errorMsg += " path size=" + TestUtil.getPathSize(path) + " minimal trials=" +  
  27.                                 finder.getPuzzle().getMinimalTrials();  
  28.                     errorMsg += " result floor=" + TestUtil.getBrokenFloor(path);  
  29.                     assertTrue(errorMsg, TestUtil.getPathSize(path) <= finder.getPuzzle().getMinimalTrials());  
  30.                     assertTrue(errorMsg, broken == TestUtil.getBrokenFloor(path));  
  31.                 }  
  32.             }  
  33.         }  
  34.     }  
  35. }  

Now we should have enough confidence.


已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Sun, 13 May 2007 03:42:03 +0800 http://jellyfish.javaeye.com/blog/79189 http://jellyfish.javaeye.com/blog/79189 Another Google question - drop glassballs from a building 3 jellyfish 作者: jellyfish  链接：http://jellyfish.javaeye.com/blog/79188  发表时间: 2007年05月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

The next step is to find the actually path of floors that we are going through to find the breaking floor. Here is the code to do that.

java 代码
 
  1. package glassball;  
  2.   
  3. import java.util.List;  
  4. import java.util.ArrayList;  
  5.   
  6. /** 
  7.  * For a given building and balls, find out the path of floors we go through 
  8.  * on the way to find the minimal floor where the ball is broken if thrown. 
  9.  */  
  10. public class PathFinder  
  11. {  
  12.     private Building building;  
  13.   
  14.     private GlassBallPuzzle puzzle;  
  15.   
  16.     public PathFinder(Building building, int numOfGlassballs)  
  17.     {  
  18.         this.building = building;  
  19.   
  20.         int totalFloors = building.getNumOfFloors();  
  21.         this.puzzle = new GlassBallPuzzle(numOfGlassballs, totalFloors);  
  22.     }  
  23.   
  24.     public GlassBallPuzzle getPuzzle() { return puzzle; }  
  25.   
  26.     public List findPuzzlePath()  
  27.     {  
  28.         int totalFloors = building.getNumOfFloors();  
  29.         int[][] sums = puzzle.getRecursiveSums();  
  30.   
  31.         // we don't need extra balls. If we don't want this optimization  
  32.         // we have to check whether a floor is higher than building's height,  
  33.         // and ignore them if it's true.  
  34.         int ballIndex = puzzle.getOptimalTrialsAndBalls()[1] - 1;  
  35.         List path = new ArrayList();  
  36.         int baseFloor = 1;  
  37.         generatePathForBallWithIndex(ballIndex, path, baseFloor, totalFloors, sums);  
  38.   
  39.         return path;  
  40.     }  
  41.   
  42.     // This is a recursive call  
  43.     private void generatePathForBallWithIndex(int ballIndex, List path,  
  44.             int baseFloor, int totalFloors, int[][] sums)  
  45.     {  
  46.         int[] floorArray = generateFloorArray(sums, ballIndex, totalFloors);  
  47.   
  48.         for (int i=0; i<floorArray.length; i++)  
  49.         {  
  50.             // -1 here because baseFloor starts with 1.  
  51.             int currentFloor = baseFloor + Math.min(totalFloors, floorArray[i] - 1);  
  52.   
  53.             boolean result;  
  54.             if (ballIndex == 0 &&  currentFloor == totalFloors)  
  55.             {  
  56.                 result = true; // only one ball case 
  57.             }  
  58.             else if (currentFloor < baseFloor + totalFloors)  
  59.             {  
  60.                 result = building.isBrokenIfThrowAt(currentFloor);  
  61.                 path.add(new Trial(currentFloor, ballIndex, result, false));  
  62.             }  
  63.             else  
  64.             {  
  65.                 result = true; // we have been here, no point to do it again.  
  66.             }  
  67.   
  68.             if (result)  
  69.             {  
  70.                 if (i > 0) baseFloor += floorArray[i-1];  
  71.   
  72.                 int floorsBetween = currentFloor - baseFloor;  
  73.   
  74.                 if (ballIndex - 1 <= 0) // 0 or 1  
  75.                 {  
  76.                     // try from bottom, one floor at a time  
  77.                     for (int k=baseFloor; k<baseFloor+floorsBetween; k++)  
  78.                     {  
  79.                         if (k <= 0) continue; // this happens when floor 1 is broken.  
  80.                         boolean stepResult = building.isBrokenIfThrowAt(k);  
  81.                         path.add(new Trial(k, ballIndex - 1, stepResult, false));  
  82.                         if (stepResult) return;  
  83.                     }  
  84.   
  85.                     // this indicate the last broken one is the floor  
  86.                     // if there is no broken one, then we need to add the last floor  
  87.                     boolean hasBroken = false;  
  88.                     boolean allBroken = true;  
  89.                     for (int j=0; j<path.size(); j++)  
  90.                     {  
  91.                         Trial trial = (Trial)path.get(j);  
  92.                         if (trial.isBroken()) hasBroken = true;  
  93.                         else allBroken = false;  
  94.                     }  
  95.   
  96.                     if (!hasBroken) path.add(new Trial(currentFloor, ballIndex, true, true));  
  97.                     if (allBroken) path.add(new Trial(currentFloor, ballIndex, true, true));  
  98.                     return;  
  99.                 }  
  100.                 else  
  101.                 {  
  102.                     // now try on ballIndex - 1 array.  
  103.                     if (floorsBetween > 0)  
  104.                     {  
  105.                         generatePathForBallWithIndex(ballIndex - 1, path,  
  106.                             baseFloor, floorsBetween, sums);  
  107.                         return;  
  108.                     }  
  109.                 }  
  110.             }  
  111.             // continue  
  112.         }  
  113.     }  
  114.   
  115.     // This method is similar to the one in GlassBallPuzzle, but is dynamic  
  116.     // since the underlying sum array varies - depends on totalFloors variable.  
  117.     private int[] generateFloorArray(int[][] sums, int ballIndex, int totalFloors)  
  118.     {  
  119.         if (ballIndex == 0)  
  120.         {  
  121.             return sums[0];  
  122.         }  
  123.   
  124.         // find the end element not to exceed totalFloors  
  125.         int[] sumArray = sums[ballIndex];  
  126.         int index = 0;  
  127.         for (int j=0; j<sumArray.length; j++)  
  128.         {  
  129.             // The equal sign is corresponding to the last trial  
  130.             // when the ball is broken.  
  131.             if (sumArray[j] >= totalFloors)  
  132.             {  
  133.                 index = j;  
  134.                 break;  
  135.             }  
  136.         }  
  137.   
  138.         // now start from the end element, sum up going to the beginning;  
  139.         sumArray = sums[ballIndex - 1];  
  140.         int[] floors = new int[index + 1];  
  141.         int total=0;  
  142.         for (int j=0; j<=index; j++)  
  143.         {  
  144.             total += sumArray[index - j];  
  145.             floors[j] = total;  
  146.         }  
  147.   
  148.         return floors;  
  149.     }  
  150. }  


The last method is to generate series (A), (B), ... dynamically. The main code is a recursion.

Here we use two other classes, Building and Trial. Building is to define the number of floors and the broken floor, which will be used for testing purpose. The Trial class is to record each trial, plus a flag to indicate whether this is a logic conclusion or not, as we discussed in the previous post listed in (i) and (ii).

java 代码
  1. package glassball;
  3. /**
  4. * To hold the state of each trial
  5. */
  6. public class Trial
  7. {
  8. private int floor;
  9. private int ballNum;
  10. private boolean broken;
  11. private boolean isDeducted = false;
  13. public Trial(int floor, int ballNum, boolean broken, boolean isDeducted)