Programmieren lernen

package ch.programmieraufgaben.simulation;

/**
 * Augabe aus Programmieraufgaben: «Brenda-Brillant»-Selction
 * Web-Code: w8an-2nw4
 * @author Philipp Gressly (phi AT gressly DOT ch)
 */
public class BrendaBrillant {
  public static void main(String[] args) {
    new BrendaBrillant().top();
  }

  // a = achat, b = brillant, c = citrin
  // Werte: 0 = an keinem Finger
  // 1 = kleiner Finger linke Hand
  // 2 = Ringfinger linke Hand
  // ..
  // 7 = Ringfinger rechte Hand
  // 8 = kleiner Finger rechts
  //     (siehe Funktion: fingerName() )
  int a, b1, b2, c;
  int ANZAHL_FINGER = 8;
  
  void top() {
    int anzahl = 0;
    for (a  = 0; a  <= ANZAHL_FINGER;  a++) {
      for (b1 = 0; b1 <= ANZAHL_FINGER; b1++) {
        for (b2 = 0; b2 <= ANZAHL_FINGER; b2++) {
          for (c  = 0; c  <= ANZAHL_FINGER;  c++) {
            if (istGueltig()) {
              anzahl = anzahl + 1;
              if (anzahl <= 366) {
                ausgabe(anzahl);
              }
            }
          }
        }
      }
    }
    System.out.println("Es gibt insgesammt " + anzahl + " Möglichkeiten.");
  } // end top();

  boolean istGueltig() {
    // mindestens ein Ring:
    int[] fingerBesetzung = new int[ANZAHL_FINGER + 1];
    if (0 == a && 0 == b1 && 0 == b2 && 0 == c) {
      return false;
    }

    // mindestens ein Ring am rechten Ringfinger:
    if (a != 7 && b1 != 7 && b2 != 7 && c != 7) {
      return false;
    }
    fingerBesetzung[a]   = 1;
    fingerBesetzung[b1] += 1;
    fingerBesetzung[b2] += 1;
    fingerBesetzung[c]  += 1;

    // Maximal zwei Ringe pro Finger
    for (int finger = 1; finger <= ANZAHL_FINGER; finger++) {
      if (fingerBesetzung[finger] > 2) {
        return false;
      }
    }

    // Brillant Vertauschung.
    // Trägt Brillant 2 eine höhere Fingernummer als Brillant 1, so
    // ignoriere diese Vertauschung
    if (b2 > b1) {
      return false;
    }

    // Alle Ausnahmen behandelt:
    return true;
  }

  void ausgabe(int variantenNummer) {
    System.out.print("Varinte " + variantenNummer + ": ");
    for (int finger = 1; finger <= 8; finger++) {
      ausgabeFinger(finger);
    }
    System.out.println();
  }

  String fingerName(int fingerNummer) {
    String linksRechts;
    if(fingerNummer <= 4) {
      linksRechts = "linken ";
    } else {
      linksRechts = "rechten ";
    }
    if(fingerNummer >= 5) { // rechte Hand spiegeln
      fingerNummer = 9 - fingerNummer;
    }
    switch (fingerNummer) {
      case 1:
        return linksRechts + "kleinen Finger";
      case 2:
        return linksRechts + "Ringfinger"    ;
      case 3:
        return linksRechts + "Mittelfinger"  ;
      case 4:
        return linksRechts + "Zeigefinger"   ;
    }
    return "FEHLER: FINGERNUMMER " + fingerNummer + " NICHT BEKANNT";
  }

  void ausgabeFinger(int fingerNummer) {
    String fingerName = fingerName(fingerNummer);
    if (a   == fingerNummer) {
      ausgabeRing("Achat"          , fingerName);
    }
    if ((b1 == fingerNummer && b2 != fingerNummer) || (b2 == fingerNummer && b1 != fingerNummer)) {
      ausgabeRing("Brillant"       , fingerName);
    }
    if (b1  == fingerNummer && b2 == fingerNummer) {
      ausgabeRing("zwei Brillanten", fingerName);
    }
    if (c   == fingerNummer) {
      ausgabeRing("Citrin"         , fingerName);
    }
  }
  
  void ausgabeRing(String edelstein, String fingerName) {
      System.out.print(edelstein + " am " + fingerName + "; ");
  }
    
} // end of class BrendaBrillant
                

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

#!/usr/bin/ruby
# -*- coding: utf-8 -*-

# @autor Philipp Gressly Freimann
# 10. Okt. 2013
#
# Aufgabe http://www.programmieraufgaben.ch / http://www.programmieren-lernen.ch
# Brenda Brillant Selection

MAX_FINGER = 8 # An welchem Finger (7=rechter Ringfinger)
ANZ_RINGE  = 4
RINGE      = 0, 0, 0, 0
$total     = 0
$soll 

def hauptprogramm() 
  print "Dieses Programm gibt alle gültigen Möglichkeiten aus (auch mehr als 366).\n"
  while(nextSelection()):
    if(gueltig()):
      ausgabe()
    end
  end
end


def gueltig() 
  #####################
  # mindestens ein Ring
  #####################
  # Muss nicht geprüft werden, da nach
  #   "nextSelection()" automatisch
  # 1, 0, 0, 0 folgt

  ####################
  # Mindestens einer am rechten Ringfinger
  ####################
  if 7!=RINGE[0] && 7!=RINGE[1] && 7!=RINGE[2] && 7!=RINGE[3]:
    return false
  end

  ###################
  # Brillanten sind identisch
  ###################
  # Nur gelten lassen, wenn Pos Diamant [2] >= Pos Diamant [1]
  if RINGE[1] < RINGE[2]:
    return false
  end

  ##################
  # Maximal zwei Ringe pro Finger
  ##################
  # Sobald ein Finger mehr als 2 Mal vorkommt: verwirf die Lösung
  #
  $f = 1
  while $f < 9:
    if vorkommen($f) > 2:
      return false
    end
    $f = $f + 1
  end
  
  ##
  # Keine Einschränkung gefunden. Also gültig:
  ##
  return true
end

def vorkommen(fingerNummer) 
  vorkommen = 0
  ringNr    = 0
  while ringNr < ANZ_RINGE:
    if RINGE[ringNr] == fingerNummer:
      vorkommen = vorkommen + 1
    end
    ringNr = ringNr + 1
  end
  return vorkommen
end

def ausgabe()
  $total = $total + 1
  print "#{$total}. Variante: "
  if(RINGE[0] > 0):
    print "Achat an "    , fingerName(RINGE[0]) , "; "
  end
  if(RINGE[1] > 0):
    print "Brillant an " , fingerName(RINGE[1]) , "; "
  end
  if(RINGE[2] > 0):
    print "Brillant an " , fingerName(RINGE[2]) , "; "
  end
  if(RINGE[3] > 0):
    print "Citrin an "   , fingerName(RINGE[3]) , "\n"
  end
end


def fingerName(fingerNummer)
  if(1 == fingerNummer): return "linkem kleinen Finger"  end
  if(2 == fingerNummer): return "linkem Ringfinger"      end 
  if(3 == fingerNummer): return "linkem Mittelfinger"    end
  if(4 == fingerNummer): return "linkem Zeigefinger"     end

  if(5 == fingerNummer): return "rechtem Zeigefinger"    end
  if(6 == fingerNummer): return "rechtem Mittelfinger"   end 
  if(7 == fingerNummer): return "RECHTEM RINGFINGER(!)"  end
  if(8 == fingerNummer): return "rechtem kleinen Finger" end
end


def nextSelection() 
  pos = 0;
  while pos < ANZ_RINGE:
    if MAX_FINGER == RINGE[pos]:
      RINGE[pos] = 0 # reset
      pos = pos + 1;
    else
      RINGE[pos] = RINGE[pos] + 1
      return true
    end
  end 
  return false
end

## MAIN ##

hauptprogramm()

##### END  #####
                

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

from copy import deepcopy

def RingKombination():
    Kombinationen = []
    d = 0
    for Ach in range(-1, 8):
        for Br2 in range(-1, 8):                 #AchatRing = 1
            for Br in range(-1, 8):              #BrillantRinge = 2
                for Ctr in range(-1, 8):         #Citrin = 3
                    Finger = [0, 0, 0, 0, 0, 0, 0, 0]

                    if Ctr != -1 and Finger[Ctr] == 0:
                        Finger[Ctr] = 3
                    elif Ctr != -1 and (Finger[Ctr] == 1 or Finger[Ctr] == 2 or Finger[Ctr] == 3):
                        Finger[Ctr] = Finger[Ctr], 3

                    if Br2 != -1 and Finger[Br2] == 0:
                        Finger[Br2] = 2
                    elif Br2 != -1 and (Finger[Br2] == 1 or  Finger[Br2] == 2 or  Finger[Br2] == 3):
                        Finger[Br2] = Finger[Br2], 2

                    if Br != -1 and Finger[Br] == 0:
                        Finger[Br] = 2
                    elif Br != -1 and (Finger[Br] == 1 or  Finger[Br] == 2 or  Finger[Br] == 3):
                        Finger[Br] = Finger[Br], 2

                    if Ach != -1 and Finger[Ach] == 0:
                        Finger[Ach] = 1
                    elif Ach != -1 and (Finger[Ach] == 1 or Finger[Ach] == 2 or Finger[Ach] == 3):
                        Finger[Ach] = Finger[Ach], 1

                    if Finger[6] != 0 and Kombinationen.count(Finger) == 0:
                            Kombinationen.append(deepcopy(Finger)) #Ringkombination wird in die Liste übernommen
                            d += 1
                            if d <= 366:
                                print("Tag", d,":", Finger)

    print("mögliche Kombinationen:",d)

RingKombination()
print("Bitteschön, Brenda.")
                

Lösung von: Daniel Kronich (Energie BKK)

String.prototype.leadZero = function(len = 4) {
  let s = this;
  while (s.length < len) s = '0' + s;
  return s;
}

let combinations = [];

/*---*\
|  §  |
\*---*/

// PRÄAMBEL
// »Mindestens einen Ring trägt sie immer.«
// --> siehe zeile 48f.

// § 1:
// »Am rechten Ringfinger ist auch immer mindestens ein Ring zu sehen.«
function par1(arr) { return arr.includes('7'); }

// § 2:
// »Pro Finger trägt sie maximal zwei Ringe.«
function par2(arr) {
  let a = arr.slice(); // Here's JavaScript. Lowcopy or get into shit.
  a.sort();
  if (a[0] == a[1] && a[0] == a[2] && a[0] != '0') return false;
  if (a[1] == a[2] && a[1] == a[3] && a[1] != '0') return false;
  return true;
}

// § 3:
// »Da die beiden Brillant-Ringe identisch aussehen, spielt ihre Vertauschung
// keine Rolle.«
function par3(arr) {
  let a = arr.slice();
  let tmp = a[1];
  a[1] = a[2];
  a[2] = tmp;
  return !combinations.includes(a.join(''));
}

// § 4:
// »Brenda kann die Ringe an beiden Händen, aber auch nur an einer Hand
// tragen.«
// --> igendwie wurscht.

// liste zubereiten
for (let i = 7; i < 6550; i++) { // '0007'-'8877': gültige kombis in basis 9
  let testArr = i.toString(9).leadZero().split('');
  if (par1(testArr) && par2(testArr) && par3(testArr))
    combinations.push(testArr.join(''));
}

function nameFinger(f) {
  switch (f) {
    case '1': return 'maldextran etfingron';
    case '2': return 'maldextran ringfingron';
    case '3': return 'maldextran mezfingron';
    case '4': return 'maldextran montrofingron';
    case '5': return 'dextran montrofingron';
    case '6': return 'dextran mezfingron';
    case '7': return 'dextran ringfingron';
    case '8': return 'dextran etfingron';
  }
}

(function combinationOfTheDay() {
  let cotd = combinations[Math.floor(Math.random() * combinations.length)];
  let out = (`
    <h1><i>Kara Brenda,</i></h1>
    <h2>la kombina?o del’ tág estas: ${cotd}</h2>
  `);
  if (cotd[0] != '0') out += (`
    <p><i>Metu l’agatringon sur la <b>${nameFinger(cotd[0])}</i></b>.</p>
  `);
  if (cotd[1] != '0') out += (`
    <p><i>Metu briliantringon sur la <b>${nameFinger(cotd[1])}</i></b>.</p>
  `);
  if (cotd[2] != '0') out += (`
    <p><i>Metu briliantringon sur la <b>${nameFinger(cotd[2])}</i></b>.</p>
  `);
  if (cotd[3] != '0') out += (`
    <p><i>Metu la citrinringon sur la <b>${nameFinger(cotd[3])}</i></b>.</p>
  `);
  out += (`<i><h2>Eliru kaj amuzi?u!</h2></i>`);
  document.write(out);
})();

                

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