The Volunteer's Dilemma

- A Computer Tournament -

Strategies' Program Parts

Overview

  1. "Gewissensbisse" by P. Ackermann (strategy's definition)

  2. "All D" by J. Arpagaus (strategy's definition)

  3. "GOLD: Group Accumulation Leads to Defection" by S. Auer (strategy's definition)

  4. "Taking Turns" by R. Bekkers (strategy's definition)

  5. "Gentle Temporiser" by R. Berger (strategy's definition)

  6. "Lazy but Fair" by F. Braun (strategy's definition)

  7. "Lazy Hero" by M. Braun (strategy's definition)

  8. "Rely on Group Pressure" by N. Braun (strategy's definition)

  9. "Finally Heroe" by J. Brüderl (strategy's definition)

  10. "Reciprocating Volunteer" by V. Buskens (strategy's definition)

  11. "Minka" by J. Deuschle (strategy's definition)

  12. "Superrational Strategy" by A. Diekmann (strategy's definition)

  13. "Hope" by H. Esser (strategy's definition)

  14. "Cooperate Unexploitably" by M. Franosch (strategy's definition)

  15. "Sponger" by T. Gautschi (strategy's definition)

  16. "Rarified Cooperation" by E. Gehmacher (strategy's definition)

  17. "2gather" by C. Hausen & K. Pforr (strategy's definition)

  18. "Kopposite" by C. Kopp (strategy's definition)

  19. "Mercy Coop" by P. Kriwy (strategy's definition)

  20. "Eve" by E. & N. Lepperhoff (strategy's definition)

  21. "Casual Hero" by U. Liebe (strategy's definition)

  22. "More Actors, Less Cooperation" by P. Preisendörfer (strategy's definition)

  23. "Sizewatcher" by B. Prosch (strategy's definition)

  24. "Tit for Tat Invers" by C. Schatz (strategy's definition)

  25. "Rent-Sharing Cooperation" by K.-U. Schnapp (strategy's definition)

  26. "Just Distribution" by H. Scholtz (strategy's definition)

  27. "Candle++" by T. Varga (strategy's definition)

  28. "Toggle" by M. Vieth (strategy's definition)

  29. "Pawlow" by T. Voss (strategy's definition)

1: "Gewissensbisse" by P. Ackermann

Program Code:
(strategy's definition) 

  private int Strategy_sim0(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 0"); }
    int strategies = simu_results[period].length; // number of strategies in combination (group size N)
  
    if (period <= 0) { // in t=1
      int choice = c_probability(1.0 / strategies);
      this.last_c = (choice > 0) ? 0 : 1; // counting the periods after the last own C-choice
      return choice;
    } else { // in t>1
      if (sum_choices(simu_results[period - 1]) < 2) { // 0 or 1 C in t-1
        int choice = c_probability(Math.pow((this.last_c * 1.0) / strategies, 2));
        this.last_c = (choice > 0) ? 0 : Math.min(this.last_c + 1, strategies);
        return choice;
      } else { // more than one C in t-1
        this.last_c = Math.min(this.last_c + 1, strategies);
        return 0;
      }
    }
  }

back to overview

2: "All D" by J. Arpagaus

Program Code:
(strategy's definition) 
  private int Strategy_sim1(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 1"); }
    return 0;
  }

back to overview

5: "Gentle Temporiser" by R. Berger

Program Code:
(strategy's definition) 
  private int Strategy_sim2(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 2"); }
    int strategies = simu_results[period].length; // number of strategies in combination (group size N)
  
    if (period < 3) { // in t<=3 (in the first three periods)
      return 0;
    } else { // in t>3
      if (simu_results[period - 1][own_idx] == 0) { // own choice was D in t-1
        if (((period + 1) % 3) == 0) { // for all periods divisible by 3
          for (int p = 1; p <= 3; p++) {
            if (sum_choices(simu_results[period - p]) > 0) { // at least one C in at least one of the last three periods
              return 0;
            }
          }
          return 1; // if no C in the last three periods AAA
        } else { // not three periods later
          return 0;
        }
      } else { // own choice was C in t-1
        if (((period + 1) % 3) == 0) { // for all periods divisible by 3
          int other_cp = 0; // correction from here: AAA
          for (int p = 1; p <= 3; p++) {
            if ((sum_choices(simu_results[period - p]) - 1) > 0) { // at least one C by others in t=t-p
              other_cp++;
            }
          }
          if (other_cp >= 3) { // at least one C by others in each of the last three periods
            return 0;
          } else { // not in each of the last three periods at least one C by others
            return 1;
          }
        } else { // not three periods later
          return 1;
        }
      }
    }
  }

back to overview

6: "Lazy but Fair" by F. Braun

Program Code:
(strategy's definition) 
  private int Strategy_sim3(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 3"); }
    int strategies = simu_results[period].length; // number of strategies in combination (group size N)
  
    if (((period + 1) % strategies) == 0) { // for all periods divisible by N
      return 1;
    } else { // for all periods not divisible by N
      return 0;
    }
  }

back to overview

7: "Lazy Hero" by M. Braun

Program Code:
(strategy's definition) 
  private int Strategy_sim4(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 4"); }
    int strategies = simu_results[period].length; // number of strategies in combination (group size N)
  
    if (period <= 0) { // in t=1
      return c_probability(1.0 / (strategies - 1)); // C with p=1/(N-1)
    } else { // in t>1
      double prob = (1.0 / (strategies - 1)) - ((sum_choices(simu_results[period - 1]) - 1.0) / strategies);
      if (prob > 0.0) {
        return c_probability(prob); // C with computed probability
      } else { // for prob<=0
        return 0;
      }
    }
  }

back to overview

8: "Rely on Group Pressure" by N. Braun

Program Code:
(strategy's definition) 
  private int Strategy_sim5(int period, int simu_results[][], int own_idx) {//if (g_debug_flg) { debug_win.document.writeln("Strategy 5"); }
    int strategies = simu_results[period].length; // number of strategies in combination (group size N)
  
    return c_probability(2.0 / (2 + strategies * (strategies - 1))); // C with computed probability
  }

back to overview

9: "Finally Heroe" by J. Brüderl

Program Code:
(strategy's definition) 
  private int Strategy_sim6(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 6"); }
    int strategies = simu_results[period].length; // number of strategies in combination (group size N)
  
    if (period <= 0) { // in t=1
      return 0;
    } else { // in t>1
      if (sum_choices(simu_results[period - 1]) > 0) { // at least one C in t-1
        return 0;
      } else { // no C in t-1
        return c_probability(1.0 / strategies); // C with p=1/N
      }
    }
  }

back to overview

10: "Reciprocating Volunteer" by V. Buskens

Program Code:
(strategy's definition) 
  private int Strategy_sim7(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 7"); }
    int strategies = simu_results[period].length; // number of strategies in combination (group size N)

    if (period <= 0) { // in t=1
      return c_probability(1.0 / 2);
    } else { // in t>1
      if (sum_choices(simu_results[period - 1]) == 0) { // no C in t-1
        return 1;
      } else { // at least one C in t-1
        int other_c = sum_choices(simu_results[period - 1]) - simu_results[period - 1][own_idx]; // C-choices from others in t-1
        return c_probability((other_c * 1.0) / strategies);
      }
    }
  }

back to overview

11: "Minka" by J. Deuschle

Program Code:
(strategy's definition) 
  private int Strategy_sim8(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 8"); }

    if (period == 1) { // in t=2
      return 1;
    } else { // in t=1 and t>=3
      return 0;
    }
  }

back to overview

12: "Superrational Strategy" by A. Diekmann

Program Code:
(strategy's definition) 
  private int Strategy_sim9(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 9"); }
    int strategies = simu_results[period].length; // number of strategies in combination (group size N)
  
    //System.out.println("DEBUG: hhh="+ (1.0 - Math.pow((1.0 / strategies) * (5.0 / 10), 1.0 / (strategies - 1))));
    return c_probability(1.0 - Math.pow((1.0 / strategies) * (5.0 / 10), 1.0 / (strategies - 1))); // C with computed probability
  }

back to overview

13: "Hope" by H. Esser,
"GOLD: Group Accumulation Leads to Defection" by S. Auer (3),
"More Actors, Less Cooperation" by P. Preisendörfer (22)

Program Code:
(strategy's definition) 
  private int Strategy_sim10(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy_sim10"); }
    int strategies = simu_results[period].length; // number of strategies in combination (group size N)
  
    return c_probability(1.0 / strategies); // C with p=1/N
  }

back to overview

14: "Cooperate Unexploitably" by M. Franosch

Program Code:
(strategy's definition) 
  private int Strategy_sim11(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 11"); }
    int strategies = simu_results[period].length; // number of strategies in combination (group size N)
  
    if (period <= 0) { // in t=1
      return c_probability(1.0 - Math.pow(1.0 / 2, 1.0 / (strategies - 1)));
    } else {
      int min_val = period; // for comparison includig the smallest number of C-choices
      int min_cnt = 0;  // counting number of strategies with the smallest number of C-choices
      for (int s = 0; s < strategies; s++) {
        if (s != own_idx) { // only the other strategies
          int c_sum = sum_periods(simu_results, 0, period - 1, s); // counting s's number of C-choices during all previous periods
          if (c_sum < min_val) {
            min_val = c_sum; // adjusting min_val to the smallest number of C-choices
            min_cnt = 1;
          } else if (c_sum == min_val) {
            min_cnt++; // adding 1 for the strategy which also had the smallest number of C-choices
          }
        }
      }
      int c_sum = sum_periods(simu_results, 0, period - 1, own_idx); // counting now the number of own C-choices during all previous periods
      if (c_sum < min_val) {
        return 1;
      } else if (c_sum > min_val) {
        return 0;
      } else { // c_sum=min_val
        return c_probability(1.0 - Math.pow(1.0 / 2, 1.0 / (min_cnt - 1)));
      }
    }
  }

back to overview

15: "Sponger" by T. Gautschi

Program Code:
(strategy's definition) 
  private int Strategy_sim12(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 12"); }
    int strategies = simu_results[period].length; // number of strategies in combination (group size N)
  
  // AAA (strategy corrections OK?)
    if (period <= 0) { // in t=1
      this.all_d = 0; // counting periods without any C
      return 0;
    } else { // in t>1
      if (sum_choices(simu_results[period - 1]) == 0) { // no C in t-1
        this.all_d++;
        if (this.all_d >= (strategies - 1)) { // no C for N-1 periods in a row
          return c_probability(1.0 / (strategies - 1)); // C with p=1/(N-1)
        } else { // at least one C during the previous N-1 periods
          return 0;
        }
      } else { //at least one C in t-1
        this.all_d = 0; // set counter for all_d-periods = 0
        return 0;
      }
    }
  }

back to overview

16: " Rarified Cooperation" by E. Gehmacher

Program Code:
(strategy's definition) 
  private int Strategy_sim13(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 13"); }
    int strategies = simu_results[period].length; // number of strategies in combination (group size N)
  
    double prob = (1.0 / strategies * 0.9) * (Math.pow((strategies / 15.0), 2.0) + 1.0) * (myrand.random() + 0.5);
    return c_probability(prob);
  }

back to overview

17: "2gather" by C. Hausen & K. Pforr

Program Code:
(strategy's definition) 
  private int Strategy_sim14(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 14"); }
    int strategies = simu_results[period].length; // number of strategies in combination (group size N)
  
    if (strategies > 2) { // for N>2
      return 0;
    } else { // for N=2
      if (period <= 0) { // in t=1
        this.unequal = 0; // indicating unequal choices in all previous periods
        return c_probability(1.0 / 2); // C with p=1/2
      } else { // in t>1
        int other_idx = (own_idx == 0)? 1 : 0; // for index of other strategy
        if (simu_results[period - 1][own_idx] != simu_results[period - 1][other_idx]) { // unequal choices in t-1
          this.unequal = 1;
        }
        if (this.unequal == 0) { // equal choices in all previous periods
          return c_probability(1.0 / 2); // C with p=1/2
        } else { // at least one previous period with unequal choices
          if (period <= 4) { // in t<=5
            return (1 - simu_results[period-1][own_idx]); // opposite of previous own choice
          } else { // in t>5
            int c_sum = sum_periods(simu_results, period - 5, period - 1, other_idx);
            if (c_sum == 0) { // no C from the other during the last 5 periods
              return 0;
            } else { // at least one C from the other during the last 5 periods
              if (c_sum > 3) { // for 4 or 5 C from the other during the last 5 periods
                return 0;
              } else { // for 3 or less C from the other during the last 5 periods
                if (period < 9) { // in t<10
                  return (1 - simu_results[period - 1][own_idx]); // opposite of previous own choice
                } else { // in t>=10
                  // check occurence of pattern D C D C
                  if (simu_results[period - 4][own_idx] == 0) { // own choice in t-4 was D
                    int eq_periods = 0; // counting periods with equal choices
                    for (int p = 1; p <= 4; p++) {
                      if (simu_results[period - p][own_idx] == simu_results[period - p][other_idx]) {
                        eq_periods++;
                      }
                    }
                    if (eq_periods == 4) { // equal choices in the 4 previous periods
                      if ((100 * simu_results[period-3][own_idx] + 10 * simu_results[period-2][own_idx] + simu_results[period-1][own_idx]) == 101) { // choice-pattern of C D C (101)
                        return 1; // pattern D C D C found
                      }
                    }
                  }
                  return (1 - simu_results[period-1][own_idx]); // opposite of previous own choice (pattern D C D C not found)
                }
              }
            }
          }
        }
      }
    }
  }

back to overview

18: "Kopposite" by C. Kopp

Program Code:
(strategy's definition) 
  private int Strategy_sim15(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 15"); }
    int strategies = simu_results[period].length; // number of strategies in combination (group size N)
  
    if (period <= 0) { // in t=1
      return 1;
    } else { // in t>1
      if (((period + 1) % strategies) == 0) { // period divisible by N
        return 1;
      } else { // period not divisible by N
        if (strategies == 2) { // for N=2
          int other_idx = (own_idx == 0)? 1 : 0; // for identifying the other player
          if (simu_results[period - 1][other_idx] > 0) { // if the other played C
            return 1;
          } else {
            return 0;
          }
        } else { // for N>2
          double prob = 0; // for computing probability for C
          int last_periods = Math.min(period, 5); // for giving the number of previous periods for t<5
          for (int p = 1; p <= last_periods; p++) {
            int d_choices = strategies - sum_choices(simu_results[period - p]); // giving the allowed number of own D-choices
            if (simu_results[period - p][own_idx] == 0) { // own choice was D in t-p
              d_choices --;
            }
            prob += (last_periods - p + 1) * (d_choices / (strategies - 1.0));
          }
          prob /= ((last_periods * (last_periods + 1.0)) / 2);
          return c_probability(prob); // C with computed probability
        }
      }
    }
  }

back to overview

19: "Mercy Coop" by P. Kriwy

Program Code:
(strategy's definition) 
  private int Strategy_sim16(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 16"); }

    return c_probability(1.0 / 10); // C with p=1/10
  }

back to overview

20: "Eve" by E. & N. Lepperhoff

Program Code:
(strategy's definition) 
  private int Strategy_sim17(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 17"); }
  
    // declaration of variables
    int anzahl_c = 0; // counting number of C-choices
    int beginn = 1; // 1:1-translation: indicating period t=1
    int w = 0; // 1:1-translation: indicating the choice
    // definition of variables
    if (period <= 0) { // in t=1
      // anzahl_c = 0;
      // beginn = 1;
    } else { // in t>1
      anzahl_c = sum_choices(simu_results[period - 1]); // counting the number of C-choices from all players in t-1
      beginn = 0;
    }
    if (beginn > 0) { // in t=1
      this.runde_d = 0; // counting the number of previous periods without any C
      this.letzte_handlung = 0; // indicating last own choice
    }
    if (anzahl_c == 0) { // no C in t-1
      this.runde_d++;
    }
    if (anzahl_c - this.letzte_handlung > 0) { // at least one C by others in t-1
      this.runde_d = 0;
    }
    if (this.runde_d >= 4) { // no C during the last 4 periods (t=0 counts as D)
      w = 1;
    } else {
      w = 0;
    }
    this.letzte_handlung = w;
    return w;
  }

back to overview

21: "Casual Hero" by U. Liebe,
"Taking Turns" by R. Bekkers (4)

Program Code:
(strategy's definition) 
  private int Strategy_sim17(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 17"); }
  
    // declaration of variables
    int anzahl_c = 0; // counting number of C-choices
    int beginn = 1; // 1:1-translation: indicating period t=1
    int w = 0; // 1:1-translation: indicating the choice
    // definition of variables
    if (period <= 0) { // in t=1
      // anzahl_c = 0;
      // beginn = 1;
    } else { // in t>1
      anzahl_c = sum_choices(simu_results[period - 1]); // counting the number of C-choices from all players in t-1
      beginn = 0;
    }
    if (beginn > 0) { // in t=1
      this.runde_d = 0; // counting the number of previous periods without any C
      this.letzte_handlung = 0; // indicating last own choice
    }
    if (anzahl_c == 0) { // no C in t-1
      this.runde_d++;
    }
    if (anzahl_c - this.letzte_handlung > 0) { // at least one C by others in t-1
      this.runde_d = 0;
    }
    if (this.runde_d >= 4) { // no C during the last 4 periods (t=0 counts as D)
      w = 1;
    } else {
      w = 0;
    }
    this.letzte_handlung = w;
    return w;
  }

back to overview

23: "Sizewatcher" by B. Prosch

Program Code:
(strategy's definition) 
  private int Strategy_sim19(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 19"); }
    int strategies = simu_results[period].length; // number of strategies in combination (group size N)

    if (period <= 0) { // in t=1
      return 0;
    } else { // in t>1
      if ((sum_choices(simu_results[period - 1]) - simu_results[period - 1][own_idx]) > 0) { // at least one C from others in t-1
        return 0;
      } else { // no C from others in t-1
        return c_probability(1.0 / strategies);
      }
    }
  }

back to overview

24: "Tit for Tat Invers" by C. Schatz

Program Code:
(strategy's definition) 
  private int Strategy_sim20(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 20"); }
  
    if (period <= 0) { // in t=1
      return 0;
    } else { // in t>1
      if (sum_choices(simu_results[period - 1]) > 0) { // at least one C in t-1
        return 0;
      } else { // no C in t-1
        return 1;
      }
    }
  }

back to overview

25: "Rent-Sharing Cooperation" by K.-U. Schnap

Program Code:
(strategy's definition) 
  private int Strategy_sim21(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 21"); }
    int strategies = simu_results[period].length; // number of strategies in combination (group size N)
  
    if (period < 1) { // t=1
      this.own_c_choices = 0; // counting number of own C-choices in a row
      return 1;
    } else { // t>1
      if (strategies <= 6) { // for N<=6
        if ((period % strategies) == 0) { // for even numbers of periods (except the first)
          return 1;
        } else { // for odd numbers of periods
          return 0;
        }
      } else { // for N>6
        if ((sum_choices(simu_results[period - 1]) - simu_results[period - 1][own_idx]) == 0) { // no C from others in t-1
          if (this.own_c_choices < 5) { // less than 5 times C in a row from oneself
            this.own_c_choices++;
            return 1;
          } else { // 5 times C in a row from oneself
            this.own_c_choices = 0;
            return 0;
          }
        } else { // at least one C from others in t-1
          return 0;
        }
      }
    }
  }

back to overview

26: "Just Distribution" by H. Scholtz

Program Code:
(strategy's definition) 
  private int Strategy_sim22(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 22"); }
    int strategies = simu_results[period].length; // number of strategies in combination (group size N)

    if (period <= 0) { // in t=1
      this.num_c = 0; // counting number of players having played C
      this.last_c = 0; // indicating period of last own C-choice
      return c_probability((period + 1.0) / strategies); // period+1=t
    } else { // in t>1
      if (simu_results[period - 1][own_idx] > 0) { // own C in t-1
        this.last_c = period; // period=t-1
        this.num_c = sum_choices(simu_results[period - 1]); // number of C-choices in t-1
      }
      if (this.last_c == 0) { // no own C so far
        return c_probability((period + 1.0) / strategies); // C with p=t/N
      } else { // at least one own C so far
        double prob = Math.max(0.0, (((period + 1) - this.last_c - strategies + this.num_c) / (this.num_c * 1.0)));
        return c_probability(prob);
      }
    }
  }

back to overview

27: "Candle++" by T. Varga

Program Code:
(strategy's definition) 
  private int Strategy_sim23(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 23"); }
    int strategies = simu_results[period].length; // number of strategies in combination (group size N)
  
    if (strategies >= 8) { // for N>=8
      return 0;
    } else { // for N<8
      if (period <= 0) { // in t=1
        this.num_cp = 0; // for num1: counting the previous periods up to t-2 with at least one C
        this.other_fc = 0; // for num2: counting the number of "follow-up-C" by others during all previous periods
        return 0;
      } else {
        if (period == 1) { // in t=2
          if (sum_choices(simu_results[period - 1]) == 0) { // no C in t=1
            return 1;
          } else { // at least one C in t=1
            return 0;
          }
        } else { // in t>=3 AAA
          int sum_p1 = sum_choices(simu_results[period - 1]); // counting number of C in t-1
          if (sum_choices(simu_results[period - 2]) > 0) { // at least one C in t-2
            this.num_cp++;
            if ((sum_p1 - simu_results[period - 1][own_idx]) > 0) { // at least one "follow-up-C" by others
              this.other_fc++;
            }
          }
          if (sum_p1 > 0) { // at least one C in t-1
            double condition_value = 0.0;
            if (this.num_cp == 0) { // no C up to t-2
              condition_value = 1.0;
            } else { // at least one C up to t-2
              condition_value = (this.other_fc * 1.0) / this.num_cp; // force double for Java AAA
            }
            if (condition_value >= (1.0 / 2)) { // own choice for t>=3 (for N<=8)
              return 0;
            } else {
              return 1;
            }
          } else { // no C in t-1
            return 1;
          }
        }
      }
    }
  }

back to overview

28: "Toggle" by M. Vieth

Program Code:
(strategy's definition) 
  private int Strategy_sim24(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 24"); }
    return ((period + 1) & 1); // C in even periods (return 1, if last binary digit equals 1)
  }

back to overview

29: "Pawlow" by T. Voss

Program Code:
(strategy's definition) 
  private int Strategy_sim25(int period, int simu_results[][], int own_idx) {
    //if (g_debug_flg) { debug_win.document.writeln("Strategy 25"); }
    int strategies = simu_results[period].length; // number of strategies in combination (group size N)
  
    if (strategies == 2) { // for N=2
      return c_probability(1.0 / 2);
    } else { // for N>2
      if (period <= 0) { // in t=1
        return 0;
      } else { // in t>1
        if (sum_choices(simu_results[period - 1]) > 0) { // at least one C in t-1
          return 0;
        } else { // no C in t-1
          return 1;
        }
      }
    }
  }

back to overview
© M&M, 13.04.2002 (last change: 13.03.2003)