Programmieren lernen

/**
 * @author Philipp Gressly (phi AT gressly DOT ch)
 * Modifikation M. Guggisberg.
 */
public class RaeuberBeuteVerhalten {
  public static void main(String[] args) {
    new RaeuberBeuteVerhalten().top();
  }
  
  void top() {
    // Populationen
    double Lalt = 15;
    double Halt = 50;
    // Proportionalitätskonstanten
    double fzuHL = 0.001; // Luchse Zuwachsrate in Abhängigkeit von Hasen und Luchsen
    double fabL  = 0.05;  // Luchse Stebrerate
    double fzuH  = 0.1;   // Hasen Zuwachsrate
    double fabHL = 0.01;  // Hasen Sterberaten in Abhängikeit von Hasen und Luchsen
    
   
    int simulationen = 1000;
    System.out.println("Luchse\tHasen");
    while(simulationen > 0) {
      double Lneu = simuliereLuchse(Lalt, fzuHL, Halt, fabL);
      double Hneu = simuliereHasen (Halt, fzuH, fabHL, Lalt);
      System.out.println((int) Lalt + "\t" + (int) Halt);
      Lalt = Lneu;
      Halt = Hneu;
      simulationen = simulationen - 1;
    }
  }

  double simuliereLuchse(double Lalt, double fzuHL, double Halt, double fabL) {
    double Lneu = Lalt + fzuHL * Halt * Lalt - fabL * Lalt;
    if(Lneu > 0) {
      return Lneu;
    }
    return 0;
  }
  
  double simuliereHasen(double Halt, double fzuH, double fabHL, double Lalt) {
    double Hneu = Halt + fzuH * Halt - fabHL * Halt * Lalt;
    if(Hneu > 0) {
      return Hneu;
    }
    return 0;
  }
  
}
 // end of class RaeuberBeuteVerhalten
                

def simuliereLuchse(Lalt, fzuHL, Halt, fabL):
    Lneu = Lalt + fzuHL * Halt * Lalt - fabL * Lalt
    if(Lneu > 0):
        return Lneu
    return 0

def simuliereHasen(Halt, fzuH, fabHL, Lalt):
    Hneu = Halt + fzuH * Halt - fabHL * Halt * Lalt;
    if(Hneu > 0):
        return Hneu
    return 0

Lalt = 15.0;
Halt = 50.0;
# Proportionalitätskonstanten
fzuHL = 0.001; # Luchse Zuwachsrate in Abhängigkeit von Hasen und Luchsen
fabL  = 0.05;  # Luchse Stebrerate
fzuH  = 0.1;   # Hasen Zuwachsrate
fabHL = 0.01;  # Hasen Sterberaten in Abhängikeit von Hasen und Luchsen
    
   
simulationen = 1000
print"Luchse\tHasen"
while(simulationen > 0):
    Lneu = simuliereLuchse(Lalt, fzuHL, Halt, fabL);
    Hneu = simuliereHasen (Halt, fzuH, fabHL, Lalt);
    print str(int(Lalt)) + "\t" + str(int(Halt))
    Lalt = Lneu
    Halt = Hneu
    simulationen = simulationen - 1
                

const LYNX_QUANTITY  = 15,      HARE_QUANTITY  = 50,
      LYNX_INCREASE  = .001,    HARE_INCREASE  = .1,
      LYNX_MORTALITY = .05,     HARE_MORTALITY = .01;

class Population {
  constructor (quantity, increase, mortality) {
    this.quantity = quantity;
    this.increase = increase;
    this.mortality = mortality;
    this.cur = 0;
  }
  calculate() {}
}

let lynx  = new Population(LYNX_QUANTITY, LYNX_INCREASE, LYNX_MORTALITY),
    hares = new Population(HARE_QUANTITY, HARE_INCREASE, HARE_MORTALITY);

lynx.calculate = function() {
  this.cur = this.quantity + this.increase * hares.quantity * this.quantity
    - this.mortality * this.quantity;
  if (this.cur < 1) this.cur = 1;
}

hares.calculate = function() {
  this.cur = this.quantity + this.increase * this.quantity
    - this.mortality * this.quantity * lynx.quantity;
  if (this.cur < 1) this.cur = 1;
}

// ausgabe
document.write(`
  <table><tr><th>Ciklo</th><th>Linkoj</th><th>Leporoj</th></tr>
    <tr><td>0</td><td>${lynx.quantity}</td>
    <td>${hares.quantity}</td></tr>
`);
for (let i = 1; i <= 1000; i++) {
  lynx.calculate(); hares.calculate();
  document.write(`
    <tr><td>${i}</td>
    <td>${Math.round(lynx.cur)}</td>
    <td>${Math.round(hares.cur)}</td></tr>
  `);
  lynx.quantity = lynx.cur;
  hares.quantity = hares.cur;
}
document.write(`</table>`);

                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

// C++ 14 | VS-2022
#include <iostream>

constexpr double    LYNX_QUA{ 15 },     HARE_QUA{ 50 },
                    LYNX_INC{ 0.001 },  HARE_INC{ 0.1 },
                    LYNX_MOR{ 0.05 },   HARE_MOR{ 0.01 };
constexpr size_t    SIMULATIONS{ 1000 };

const struct population {
    const double this_qua, other_qua, this_inc, this_mor;
};

constexpr inline auto get_lynx_current(const population& p_) noexcept {
    const auto cur{ p_.this_qua + p_.this_inc * p_.other_qua * p_.this_qua - p_.this_mor * p_.this_qua };
    return cur < 1 ? 1 : cur;
}

constexpr inline auto get_hare_current(const population& p_) noexcept {
    const auto cur{ p_.this_qua + p_.this_inc * p_.this_qua - p_.this_mor * p_.this_qua * p_.other_qua };
    return cur < 1 ? 1 : cur;
}

int main() {
    auto lynx_cur{ LYNX_QUA }, hare_cur{ HARE_QUA };
    auto i{ SIMULATIONS };

    while (--i) {
        std::cout << "Lynx: " << lynx_cur << "; Hare: " << hare_cur << "\n";
        lynx_cur = get_lynx_current(population{ lynx_cur, hare_cur, LYNX_INC, LYNX_MOR });
        hare_cur = get_hare_current(population{ hare_cur, lynx_cur, HARE_INC, HARE_MOR });
    }
}
                

Lösung von: Jens Kelm (@JKooP)