Programmieren lernen

import java.util.Scanner;

public class PushBackScanner {
  Scanner sc;
  
  String betrachte;
  
  public PushBackScanner(String scannable) {
    sc = new Scanner(scannable); }
  
  /*
   *  Betrachte das nächste Symbol.
   *  Zeige es, oder zeige "null", falls kein Symbol mehr vorhanden ist.
   */
  public String zeigeNaechstesSymbol() {
    if(betrachte != null) {
      return betrachte;      }
    int nextInt;
    try {
      nextInt = sc.nextInt();
      betrachte = "" + nextInt;
      return betrachte;      } 
    catch (Exception ex) { } // no int
    try {
      String c = sc.next(); // "(", ")", "+" oder "|"
      betrachte = "" + c;
      return betrachte; }
    catch (Exception ex) {
      return null;  } // end of file?
  }
  
  /**
   * Vernichte das aktuelle Symbol in der "Warteschlange"
   */
  public void symbolWurdeBenutzt() {
      betrachte = null; }

} // end of class Scanner

/***********************************/

public class Widerstand {

  PushBackScanner scanner;
   
  public Widerstand() {
    this("( 3 | 4 + 5 ) + 4 + 5 | 6 + 7 | ( 8 + 9 ) + 4 | 30");
  }
  public Widerstand(String schaltung) {
    this.scanner = new PushBackScanner(schaltung);
    System.out.println(schaltung + " ergibt " 
                         + parseSchaltung() + " Ohm.");
  }
  
  public double parseSchaltung() {
    double value = parseSummand();
    // Pluszeichen?
    while("+".equals(scanner.zeigeNaechstesSymbol())) {
      scanner.symbolWurdeBenutzt();
      value = value + parseSummand(); }
      return value;  }
   
  public double parseSummand() {
    double invValue = 1.0 / parseWiderstand();
    // Senkrechten Strich (= Parallelschaltung)
    while("|".equals(scanner.zeigeNaechstesSymbol())) {
      scanner.symbolWurdeBenutzt();
      invValue = invValue +
                 1.0 / parseWiderstand(); }
    return 1.0 / invValue;  }
    
  private double parseWiderstand() {
    String sc = scanner.zeigeNaechstesSymbol();
    if("(" .equals(sc)) {
      scanner.symbolWurdeBenutzt();
      double value =  parseSchaltung();
      sc = scanner.zeigeNaechstesSymbol();
      if(")".equals(sc)) {
        scanner.symbolWurdeBenutzt();
        return value; } 
      else {
        System.out.println("Error in parsing ')' expected.");
        System.exit(0); } // Throw exception
    }
    // Muss eine Zahl sein, denn der Fall des Klammerausdrucks wurde
    // bereits behandelt:
    if(istGanzzahl(sc)) {
      scanner.symbolWurdeBenutzt();
      int w = Integer.parseInt(sc);
      return w; }
    else {
      System.out.println("Error in parsing: Number expected.");
      System.exit(0); }
    return 0; } //unreachable 

  private boolean istGanzzahl(String sc) {
    try {
      Integer.parseInt(sc); }
    catch (NumberFormatException nfe) {
      return false;  }
    return true;  }
  
  public static void main(String[] args) {
    new Widerstand();  }
}

                

# Komplett neuer Parser in Ruby
#   Kombi aus rekursiver und iterativer Auflösung des eingegebenen Netzwerks
#   -> nutzt den Eingabestring via "Suchen und Ersetzen" als eine Art Stack-Ersatz.

def get_operand_boundaries(operator, str)
    # Zeichengrenzen der Operanden berechnen
    # a -> Start erste Zahl
    # b -> Stelle des Operators = Ende erste Zahl, Anfang zweite Zahl
    # c -> Ende zweite Zahl

    if str.include?(operator)

        b = str.index(operator)
        
        before_operator = str[0, b]
        after_operator = str[b+1, str.length]
        
        a1 = before_operator.rindex("|")
        if not a1
            a1 = 0
        end
        
        a2 = before_operator.rindex("+")
        if not a2
            a2 = 0
        end
        
        a = [a1, a2].max()
        
        c1 = after_operator.index("|")
        if not c1
            c1 = after_operator.length
        end
        
        c2 = after_operator.index("+")
        if not c2
            c2 = after_operator.length
        end        
        
        c = [c1, c2].min()
        c+=b
    
        return [a, b, c]
    
    else
    
        return nil
        
    end

end

def parser(input)

    while input.include?("(") # Löse zuerst _alle_ Klammern und deren Inhalt im akutellen Ausdruck (rekursiv)

        a = input.index("(")
        b = input[a, input.length].index(")")

        result = parser(input[a + 1, b - 1])
        input[a, b + 1] = result
        
    end
    
    while (input.include?("|")) # Löse danach von links nach rechts den |-Operator im aktuellen Ausruck auf (iterativ)

        boundaries = get_operand_boundaries("|", input)
        
        if boundaries

            x = input[boundaries[0] + 1, boundaries[1]].chomp.to_f()
            y = input[boundaries[1] + 1, boundaries[2]].chomp.to_f()
            
            result = 1.0 * x * y / (x + y)
            input[boundaries[0] + 1, boundaries[2] - boundaries[0] - 1] = result.to_s
            
        end
        
    end
        
    while (input.include?("+")) # Löse zum Schluss v.l.n.r. den +-Operator im aktuellen Ausdruck auf (iterativ)

        boundaries = get_operand_boundaries("+", input)
        
        if boundaries
        
            x = input[boundaries[0] + 1, boundaries[1]].chomp.to_f()
            y = input[boundaries[1] + 1, boundaries[2]].chomp.to_f()
            
            result = x + y
            input[boundaries[0] + 1, boundaries[2] - boundaries[0] - 1] = result.to_s
            
        end
        
    end
    
    return input
end



puts "Gib ein Widerstandsnetzwerk ein:"
input = gets.chomp
puts "Wert des Netzwerkes:"
print parser(input), " Ohm"

                

Lösung von: Ich Bins (tubs)