Programmieren lernen

import java.util.Scanner;

public class Sampling {
  public static void main(String[] args) {
     new Sampling().start();  }
  
  
  String reservoir[]; // 0..t-1 (t = anzahl gesuchte testdaten)
  String nextLine   ;
  
  
  void start() {
      initReservoir(3);
      while(nextData()) {
          addData();  }
      output();  }


  /**
   * @param i The number of samples to store.
   */
  private void initReservoir(int i) {
    reservoir = new String[i]; }
  
  
  /**
   * Read a line into "nextLine".
   * After the last line false will be returned.
   * @return true, iff the "nextLine" is valid.
   */
  boolean nextData() {
      Scanner sc = new Scanner(System.in);
      System.out.println("Next data (<empty> to quit): ");
      nextLine = sc.nextLine();
      if(null == nextLine) {
          return false; }
      if("".equals(nextLine)) {
          return false; }
      return true; }
  
  
  void output() {
      // reservoir evtl hier mischen.
      if(alreadyRead < reservoir.length) {
          System.out.println("Not enough data."); }
      for(String act : reservoir) {
          System.out.println("Sample: " + act); }
  }
  
  
  /**
   * Add the "nextLine" if required to the reservoir.
   */
  int alreadyRead = 0;
  void addData() {
     int positionToAdd;
     if(alreadyRead < reservoir.length) {
         positionToAdd = alreadyRead;   } 
     else {
         positionToAdd = intRnd(alreadyRead); }
     if(positionToAdd < reservoir.length) {
         reservoir[positionToAdd] = nextLine; }
     alreadyRead = alreadyRead + 1;
  }

  
  /**
   * Generate an integer random number between
   * 0 and "size - 1".
   */
  private int intRnd(int size) {
    return (int) (Math.random() * (size + 1)); }

}  // end of class Sampling
                

public class Reservoir {

    double[] reservoir;
    int size;
    int numIns;

    public static void main(String[] args) {
        Reservoir m = new Reservoir( 1000 );

        for( double j = 0; j <= 1000000; j++ )
            m.Add( j );

        System.out.println( "Mittelwert im Reservoir : " + m.Average() );
    }

    public Reservoir( int size ) {
        reservoir = new double[size];
        this.size = size;
        numIns = 0;
    }

    public void Add( double val ) {
        if ( numIns < size )
            reservoir[numIns] = val;
        else {
            int curIndex = (int) Math.floor( Math.random() * (numIns+1) );
            if ( curIndex < size )
                reservoir[curIndex] = val;
        }        
        numIns++;
    }

    public void Reset( ) {
        numIns = 0;
    }

    public void Print( ) {
        for( int i = 0; i < size; i++ )
            System.out.println( reservoir[i] );
    }

    public double Average( ) {
        double sum = 0;

        for( int i = 0; i < size; i++ )
            sum += reservoir[i];
        sum /= size;
        return sum;
    }
}

                

package g2.testdaten;

import java.io.*;
import java.util.Arrays;


public class Testdaten {
    
  public static void main(String[] args) {
    try {
        new Testdaten().top();
    } catch (IOException e) {
       System.out.println("Fehler im File: " + e);
        e.printStackTrace();
    }
  }
  
  int RESERVOIR_ANZAHL = 20;
  String[]       reservoir;
  BufferedReader br;
  
  void top() throws IOException {
     br = readerInitialisieren();
     reservoirInitialisieren();
     sampling();
     br.close();
     reservoirAusgeben();
  }

  void sampling() throws IOException {
     String line;
     int k = RESERVOIR_ANZAHL  + 1;
     while(null != (line = br.readLine())) {
        int zufallszahl = zufall(0, k-1);
        if(zufallszahl < RESERVOIR_ANZAHL) {
          reservoir[zufallszahl] = line;
        }
        k = k + 1;
     }
  }
  
  void reservoirAusgeben() {
      Arrays.sort(reservoir);
      for(String wort: reservoir) {
          System.out.println(wort);
      }
  }
     
  int zufall(int min, int max) {
      return min + (int) (Math.random() * (max - min + 1)); 
  }
  
  BufferedReader readerInitialisieren() {
    try {
        FileReader fr = new FileReader("deutsch.txt");
        return new BufferedReader(fr);
    } catch(IOException ex) {
        System.out.println("Fehler beim File öffnen: " + ex);
    }
    return null;
  }
      
  void reservoirInitialisieren() throws IOException {    
      reservoir = new String[RESERVOIR_ANZAHL];
      for(int i = 0; i < RESERVOIR_ANZAHL; i = i + 1) {
         reservoir[i] = br.readLine();
      }
  }
  
} // end of class Testdaten
                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

class Reservoir extends Array {
  constructor (size) {
    super();
    this.size = size || 100;
  }
  read(data) {
    let dLen = data.length;
    while (this.length < this.size) this.push(data.shift());
    while (data.length > 0) {
      let p = Math.floor(Math.random() * dLen),
          k = data.shift();
      if (p < this.size) this.splice(p, 1, k);
    }
    if (this.length < this.size) console.warn('Zu wenige Daten');
  }
}

// test
let r = new Reservoir(2),
    d = [1, 2, 3];

r.read(d);
console.log(r.sort().join(', '));
                

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