本帖最后由 dengxu11 于 2011-09-29 13:10:09 编辑

解决方案 »

  1.   


    /**
     * 男1-->套1-fuck->女1,  男2-->套2-fuck->女2
     * 男1-->套1-->套2-fuck->女2
     * 男2-->套2-->套1-fuck->女1
     */
    太要命了
      

  2.   

    三男三女过河,船上只能坐两个人  如果man>woman  woman will be  fuck   怎么过
      

  3.   

    第一次 A男 带A B套 A套外面B套里面 与A女接触 摘下外面的A套 与B女接触   
    B男带上 A套与 A女接触 不摘A套 带上B套 与B女接触。。
      

  4.   

    男 1 套1 +套2 ---> 女1
    男1 套2 ---> 女2
    男2 套1 ---> 女1
    男2 套2 + 套1 ---> 女2求代码!!!!
      

  5.   

    关于设计模式,我想使用到了装饰模式,
    DataInputStream dis = new DataInputStream(new BufferedInputStream(new FileInputStream());
      

  6.   

    男1->T1->T2  女2
    男1->T1 女1
    男2->T2 女2
    男2->T2->T1 女1对否
      

  7.   

    男 1     套1 +套2 ---> 女1
    男1     套1 ---> 女2
    男2     套2 ---> 女1
    男2     套2 + 套1 ---> 女2这个是对的吧,,,
      

  8.   

    保证一个套只接触一个女的,第一个男的带两个套,fuck第一个女的后摘下给第二个男的带上fuck第一个女的,第一个男的用里面的那个套fuck第二个女的,摘下给第二个男的带上fuck第二个女的!!!
      

  9.   

    知道可以串联就简单了一个人只能用TT的一面,所以每个人对应一个TT,然后带着TT XX。什么设计模式还真不知道TT.java
    package sex;public class TT {
    private String name;

    public TT(String name) {
    this.name = name;
    }
    public String getName() {
    return name;
    }
    public void setName(String name) {
    this.name = name;
    }
    }
    Person.java
    package sex;public class Person {
    private String name;
    private TT tt;

    public Person() {
    }
    public Person(String name, TT tt) {
    this.name = name;
    this.tt = tt;
    }
    public TT getTt() {
    return tt;
    }
    public void setTt(TT tt) {
    this.tt = tt;
    }
    public String getName() {
    return name;
    }
    public void setName(String name) {
    this.name = name;
    }

    }测试类
      

  10.   


    package sex;import java.util.ArrayList;
    import java.util.List;public class aa {
    public static void main(String[] args) {

     Person m1 = new Person ("m1",new TT("tt1"));
     Person m2 = new Person ("m2",new TT("tt2"));
     Person f1 = new Person ("f1",new TT("tt1"));
     Person f2 = new Person ("f2",new TT("tt2"));
     
     List<Person> ms = new ArrayList<Person>();
     List<Person> fs = new ArrayList<Person>();
     ms.add(m1);
     ms.add(m2);
     fs.add(f1);
     fs.add(f2);
     for (Person m:ms){
     for(Person f:fs){
     if(m.getTt().getName().equals(f.getTt().getName())){
     System.out.print(m.getName());
     System.out.print("------>");
     System.out.print(m.getTt().getName());
     System.out.print("------>");
     System.out.println(f.getName());
     }else{
     System.out.print(m.getName());
     System.out.print("------>");
     System.out.print(m.getTt().getName());
     System.out.print(">");
     System.out.print(f.getTt().getName());
     System.out.print("------>");
     System.out.println(f.getName());
     }
     }
     }
    }
    }
    结果
    m1------>tt1------>f1
    m1------>tt1>tt2------>f2
    m2------>tt2>tt1------>f1
    m2------>tt2------>f2
      

  11.   

    这样学的才HAPPY嘛, 学的才快而且考试的时候也。
      

  12.   

    7楼的第三行,男2再套套2时,套2已经被感染了,应该是分为以下四步:1.  男1 -->套1+套2--->女1(男1将套2给男2)
    2.  男1 -->套1--->女2
    3.  男2 -->套2-->女1
    4.  男2 -->套2+套1-->女2
      

  13.   

      哦,了解!!忽略其他偶然因素,答案应该是这样的:
      男1先带两个套f女1,然后脱一个给男2,男2f女1,男1f女2,男1 f之后脱了给套给男2,男2带上两个套f女2!
      

  14.   


    //可以fuck别人的
    public interface Fuckable {
    public String getName();
    boolean fuck(Fuckedable fuckee);
    boolean addFuckee(Fuckedable fuckee);
    }
    //可以被fuck的
    public interface Fuckedable {
    public String getName();
    boolean addFucker(Fuckable fucker);
    }
    //代表男人,实现Fuckable接口,可以fuck别人
    public class Male implements Fuckable{
    }
    //代表女人,实现Fuckedable接口,可以被fuck
    public class FeMale implements Fuckedable{
    }
    //代表套,既可以fuck,也可以被fuck
    public class Condom implements Fuckable, Fuckedable {
    }
    Condom这个类很关键,因为现在的问题转化为:
    男人->套
    套->套
    套->女人
    //工厂类
    public class FuckeeFactory{
        //可能是一个FeMale,也可能是Condom
        public static Fuckedable getFuckee(){
        }
    }
    public class FuckerFactory {
        //可能是一个Male,也可能是Condom
        public static Fuckable getFucker(){
        }
    }
    //成功的一次fuck
    public class ResultItem {
    private final Fuckable fucker;
    private final Fuckedable fuckee;
    }
    //把中间结果存放到ThreadLocal里面:
    public class Utils {
    public static ThreadLocal<Set<ResultItem>> results = new ThreadLocal<Set<ResultItem>>();
    public static void put(ResultItem item){
    Set<ResultItem> result = results.get();
    if(result == null){
    result = new HashSet<ResultItem>();
    }
    result.add(item);
    results.set(result);

    }
    public static Set<ResultItem> getResult(){
    return results.get();
    }
    }
    昨晚上写了大半晚上,大概的代码是这个样子,搞定,收工!
      

  15.   


    //可以fuck别人的
    public interface Fuckable {
    public String getName();
    boolean fuck(Fuckedable fuckee);
    boolean addFuckee(Fuckedable fuckee);
    }
    //可以被fuck的
    public interface Fuckedable {
    public String getName();
    boolean addFucker(Fuckable fucker);
    }
    //代表男人,实现Fuckable接口,可以fuck别人
    public class Male implements Fuckable{
    }
    //代表女人,实现Fuckedable接口,可以被fuck
    public class FeMale implements Fuckedable{
    }
    //代表套,既可以fuck,也可以被fuck
    public class Condom implements Fuckable, Fuckedable {
    }
    Condom这个类很关键,因为现在的问题转化为:
    男人->套
    套->套
    套->女人
    //工厂类
    public class FuckeeFactory{
        //可能是一个FeMale,也可能是Condom
        public static Fuckedable getFuckee(){
        }
    }
    public class FuckerFactory {
        //可能是一个Male,也可能是Condom
        public static Fuckable getFucker(){
        }
    }
    //成功的一次fuck
    public class ResultItem {
    private final Fuckable fucker;
    private final Fuckedable fuckee;
    }
    //把中间结果存放到ThreadLocal里面:
    public class Utils {
    public static ThreadLocal<Set<ResultItem>> results = new ThreadLocal<Set<ResultItem>>();
    public static void put(ResultItem item){
    Set<ResultItem> result = results.get();
    if(result == null){
    result = new HashSet<ResultItem>();
    }
    result.add(item);
    results.set(result);

    }
    public static Set<ResultItem> getResult(){
    return results.get();
    }
    }
    昨晚上写了大半晚上,大概的代码是这个样子,搞定,收工!
      

  16.   


    //可以fuck别人的
    public interface Fuckable {
    public String getName();
    boolean fuck(Fuckedable fuckee);
    boolean addFuckee(Fuckedable fuckee);
    }
    //可以被fuck的
    public interface Fuckedable {
    public String getName();
    boolean addFucker(Fuckable fucker);
    }
    //代表男人,实现Fuckable接口,可以fuck别人
    public class Male implements Fuckable{
    }
    //代表女人,实现Fuckedable接口,可以被fuck
    public class FeMale implements Fuckedable{
    }
    //代表套,既可以fuck,也可以被fuck
    public class Condom implements Fuckable, Fuckedable {
    }
    Condom这个类很关键,因为现在的问题转化为:
    男人->套
    套->套
    套->女人
    //工厂类
    public class FuckeeFactory{
        //可能是一个FeMale,也可能是Condom
        public static Fuckedable getFuckee(){
        }
    }
    public class FuckerFactory {
        //可能是一个Male,也可能是Condom
        public static Fuckable getFucker(){
        }
    }
    //成功的一次fuck
    public class ResultItem {
    private final Fuckable fucker;
    private final Fuckedable fuckee;
    }
    //把中间结果存放到ThreadLocal里面:
    public class Utils {
    public static ThreadLocal<Set<ResultItem>> results = new ThreadLocal<Set<ResultItem>>();
    public static void put(ResultItem item){
    Set<ResultItem> result = results.get();
    if(result == null){
    result = new HashSet<ResultItem>();
    }
    result.add(item);
    results.set(result);

    }
    public static Set<ResultItem> getResult(){
    return results.get();
    }
    }
    昨晚上写了大半晚上,大概的代码是这个样子,搞定,收工!
      

  17.   

    哈佛大学入学考试不可能去考什么 Java !
      

  18.   

    File 女1 = 图片(字节)
    File 女2 = 文本(字符)FileInputStream 套1 
    FileReader 套2InputStreamReader 套1+套2