Programmieren lernen

package eu.gressly.hw.iteration.wage;

import java.util.Scanner;

/**
 * Berechne die Gewichte in der Wage-Zusatzaufabe (3-er System) 
 * @author Philipp Gressly (phi@gress.ly)
 */
/*
 * History: first Implementation: May 21, 2010
 * Bugs   :
 */
public class Wage {
  public static void main(String[] args) {
    new Wage().top();
  }
  
  void top() {
      int gewicht;
      gewicht = einlesen("das Gewicht");
      iterativesAusegebn(gewicht);
  }
  
  
  void iterativesAusegebn(int warenGewicht) {
    int aktuellerGewichtsstein = 1; // wird nur zu Ausgabe verwendet.
    while(0 < warenGewicht) {
      int rest = warenGewicht % 3;
      if(1 == rest) {
          System.out.println("Gewichtsstein " + aktuellerGewichtsstein + " auf die rechte Seite legen.");
          warenGewicht = warenGewicht - 1; // Korrektur
      }
      if(2 == rest) {
          System.out.println("Gewichtsstein " + aktuellerGewichtsstein + " auf die linke Seite legen.");
          warenGewicht = warenGewicht + 1; // Korrektur
      }
      // Problem um Faktor 3 reduzieren:
      aktuellerGewichtsstein = aktuellerGewichtsstein * 3;
      warenGewicht           = warenGewicht / 3;
    }
  }



Scanner sc = new Scanner(System.in);
  int einlesen(String input) {
    System.out.println("Bitte " + input + " eingeben: ");
    return sc.nextInt();
  }
  
} // end of class Wage
                

# Gewichtsteine 1-2-4-8-16-32-64
def gewichtSteine2(w):
    s = bin(w)
    s2 = s[2:len(s)]
    pos = len(s2)-1
    for c in s2:
        if c == '1':
            g = 1<<pos
            print 'Benutzen Sie den Gewichtstein kg: '+str(g)
        pos = pos -1

# Gewichtsteine 1-3-9-27-81-243
def gewichtSteine3(w):
    teilbarkeit =[1,3,9,27,81,243]
    l=[]
    r=[]
    zahl = w
    print zahl
    for kor in teilbarkeit:
        #print 'zahl:'+str(zahl)
        #print 'kor: '+str(kor)
        #print 't: '+str(t)
        teilbar = kor *3
        if ((zahl - kor) % teilbar ==0):
            r.append(kor)
            #print 'korrektur kleiner'
            zahl = zahl - kor
        else:
            if ((zahl + kor) % teilbar ==0):
                #print 'korrektur groesser'
                l.append(kor)
                zahl = zahl + kor    

    print 'Fuer das Gewicht [kg]: '+str(w)
    print 'Linke Seite: '
    for g in l:
        print 'Gewicht: \t\t'+str(g)
    print 'Rechte Seite: '
    for g in r:
        print 'Gewicht: \t\t'+str(g)


gewichtSteine2(123)
gewichtSteine3(123)
#for x in range(300):
#    gewichtSteine3(x)
    
                

Lösung von: Martin Guggisberg (Universität Basel / PH FHNW)

using System;

namespace Waage {
	class Program {
		static void Main(string[] args) {
			sbyte
				gewichte = -1,
				vergleichsByte = 1;

			while (gewichte < 0) {
				Console.Clear();
				Console.Write("Gewicht (0-127 kg)>");
				try { gewichte = Convert.ToSByte(Console.ReadLine()); }
				catch (Exception) { }
			}

			Console.WriteLine("\nBenötigte Gewichte:");
			for (int i = 0; i < 7; i++) {
				if ((gewichte & vergleichsByte) == vergleichsByte)
					Console.Write("\n{0,2} kg", Math.Pow(2, i));
				vergleichsByte <<= 1;
			}

			Console.ReadKey(true);
		}
	}
}

                

Lösung von: Marcel Kapma ()

gewichte = [1, 2, 4, 8, 16, 32, 64]
gewichte = sorted(gewichte)[::-1]

inp = 50

for g in gewichte:
    if g <= inp:
        inp -= g
        print(g)

                

Lösung von: Name nicht veröffentlicht

// einfache Aufgabe (Gewichte nur auf einer Seite der Waage)

package it.programmieraufgaben.alex;

import java.util.Scanner;

public class Waage {

	public static void main(String[] args) {

		// Das zu pruefende Gewicht abfragen
			int gewicht = 0;
			Scanner zuWiegendesGewicht = new Scanner(System.in);
			System.out.println("Bitte das zu wiegende Gewicht eingeben:");
			gewicht = zuWiegendesGewicht.nextInt();

		// Das eingegebene Gewicht in eine binaere Zahl umwandeln
			String binZahl = "";
			binZahl = Integer.toBinaryString(gewicht);

		
		
		// Pruefen, ob die Variable binZahl 7 Stellen hat
			int[] zahlArray = new int[7];
			int anZahlStellenBinZahl = binZahl.length();
			int zuWenigStellen = 0;
			if (anZahlStellenBinZahl < 7) {
				zuWenigStellen = 7 - anZahlStellenBinZahl;
			}

		// eventuelle fehlende fuehrende Nullen in die binZahl - Variable
		// einfuegen
			int t = 0;
			for (t = 0; t < zuWenigStellen; t++) {
				binZahl = "0" + binZahl;
			}

		// die Gegengewichte in eine Array eintragen
			for (int i = 6; i >= 0; i--) {
				double binzahlDbl = (Math.pow(2, i));
				int binZahlInt = (int) binzahlDbl;
				zahlArray[i] = binZahlInt;
			}
		
		// Berechnung der notwendigen Gegengewichte
			System.out.println(
					"Fuer das zu pruefende Gewicht von " + gewicht + "kg muessen folgende Gegengewichte verwendet werden:");
			for (int z = 0; z < 7; z++) {
				char binArray = binZahl.charAt(z);
				if (binArray == '1') {
					int y = 6 - z;
				System.out.print(" " + zahlArray[y] + "kg");
			}

		}
	}

}		
		
                

Lösung von: Alex Mahlknecht (Privater Unterricht)

// WAAGE MIT POTENZEN BASIS 3

package it.programmieraufgaben.alex;

import java.util.Scanner;

public class Waage2 {

	public static void main(String[] args) {

		System.out.println("Bitte das zu wiegende Gewicht eingeben!");
		Scanner gewicht = new Scanner(System.in);
		int zuPruefendesGewicht = gewicht.nextInt();

		// Werte Array laden
		int[] werteGewichte = new int[6];
		int[] wertePotenzen = new int[6];
		int[] werteSumPotenzen = new int[6];
		int arrayZaehler = 1;
		int summeWerte = 1;
		int potenzZahl = 1;
		int summeGewichte = 0;
		int restWert = 0;
		int summeGewichtZaehler = 0;
		int werteGewichtZaehler = 5;

		// Schleife fuer Array starten
		wertePotenzen[0] = 1;
		werteSumPotenzen[0] = 1;

		// Array mit den Potenzzahlen und den Potenzsummen befuellen

		while (summeWerte < zuPruefendesGewicht) {
			wertePotenzen[arrayZaehler] = (int) Math.pow(3, potenzZahl);
			werteSumPotenzen[arrayZaehler] = summeWerte + wertePotenzen[arrayZaehler];
			summeWerte = summeWerte + wertePotenzen[arrayZaehler];
			summeGewichte = wertePotenzen[arrayZaehler];
			if (summeWerte >= zuPruefendesGewicht) {
				break;
			}
			;

			arrayZaehler++;
			potenzZahl++;

			if (arrayZaehler >= wertePotenzen.length) {
				break;
			}
			;

		}
		;

		// erstes Gewicht in das Gewichtsarray eintragen

		werteGewichte[werteGewichtZaehler] = wertePotenzen[arrayZaehler];
		werteGewichtZaehler--;


		
		// ********   restliche Gewicht ermittlen   ********

		while (arrayZaehler >= 0) {

			restWert = zuPruefendesGewicht - summeGewichte;
			arrayZaehler--;

			// mit dieser Schleife wird der naechste Potenzwert ermittelt

			for (summeGewichtZaehler = 0; summeGewichtZaehler <= (arrayZaehler - 1); summeGewichtZaehler++) {
				if (wertePotenzen[summeGewichtZaehler] >= (int) Math.abs(restWert)) {
					break;
				}
			}
			;

			// Restwert wird ueberprueft, ob er negativ oder positiv ist

			if (restWert > 0) {

				// Fall positiv

				if (summeGewichtZaehler > 0) {

					if (werteSumPotenzen[summeGewichtZaehler - 1] == Math.abs(restWert)) {
						summeGewichtZaehler--;
					}

				}
				;

				werteGewichte[werteGewichtZaehler] = wertePotenzen[summeGewichtZaehler];
				summeGewichte = summeGewichte + wertePotenzen[summeGewichtZaehler];

				// Fall negativ

			} else if (restWert < 0) {

				if (summeGewichtZaehler > 0) {

					if (werteSumPotenzen[summeGewichtZaehler - 1] == Math.abs(restWert)) {
						summeGewichtZaehler--;
					}

				}
				;

				werteGewichte[werteGewichtZaehler] = wertePotenzen[summeGewichtZaehler] * (-1);
				summeGewichte = summeGewichte + (wertePotenzen[summeGewichtZaehler] * (-1));

			}

			// Fall null

			else {
				// arrayZaehler--;
				break;
			}
			;

			// verhindern, dass der Arrayzaehler unter null geht

			if (werteGewichtZaehler == 0) {
				break;
			} else {
				werteGewichtZaehler--;
			}
			;

		}

		// Gewichte ausgeben; negative Gewichte muessen auf die linke Seite der
		// Waage gegeben werden, positive Gewichte kommen auf die rechte Seite
		// der Waage

		System.out.println("werteGewichte= " + werteGewichte[5]);
		System.out.println("werteGewichte= " + werteGewichte[4]);
		System.out.println("werteGewichte= " + werteGewichte[3]);
		System.out.println("werteGewichte= " + werteGewichte[2]);
		System.out.println("werteGewichte= " + werteGewichte[1]);
		System.out.println("werteGewichte= " + werteGewichte[0]);

	}
}

                

Lösung von: Alex Mahlknecht (Privater Unterricht)

gewicht = int(input('Gewicht: '))
stein = 64
while gewicht > 0:
    if gewicht >= stein:
        print(stein, end=' ')
        gewicht = gewicht - stein
    stein = stein // 2



                

Lösung von: Claude Vonlanthen (Kantonsschule Olten)

/*-------------------------------*\
| E R S T E   W A A G E          |
\*-------------------------------*/

function setOfScales1(num) {
  let weights = [1, 2, 4, 8, 16, 32, 64],
      out = [];
  num = num.toString(2).split('').reverse();
  for (let i = 0; i < num.length; i++)
    if (num[i] == '1') out.push(weights[i]);
  return out;
}

/*----------------------------------------------------*\
| Z W E I T E   W A A G E                              |
|------------------------------------------------------|
| Denkfaul, wie ich bin, hab ich mich erstmal für eine |
| brachialmethode entschieden. Sie ist größer (und     |
| brachialer) geworden, als ich anfangs glaubte,       |
| trotzdem läuft sie flott und tut, was sie soll.      |
\*----------------------------------------------------*/

// paar hilfsunktiönchen
String.prototype.hasDoubles = function() {
  for (let i = 0; i < this.length; i++)
    if (this.includes(this[i], i+1)) return true;
  return false;
}
Array.prototype.sum = function() { return eval(this.join('+')); }

function setOfScales2(num) {
  let weights = [1, 3, 9, 27, 81, 243],
      candidates = ['0'];   // liste möglicher gewichtssteinkombis
  function isCandidate(str) {
    if (str.indexOf('0') != -1) return false;
    for (let i = 0; i < str.length-1; i++)  // aufsteigende reihenfolge?
      if (str.charCodeAt(i) >= str.charCodeAt(i+1)) return false;
    return true;
  }
  // konvertiert die basis-7-zahlen (string) in gewichtssteine (array)
  function convert(str) {
    if (str == '0') return [0];
    let out = [];
    for (let i = 0; i < str.length; i++)
      out.push( weights[parseInt(str[i])-1] );
    return out;
  }
  for (let i = 1; i < 22875; i++) {  // 22875_10 = 123456_7
    let candidate = i.toString(7);
    if (isCandidate(candidate)) candidates.push(candidate);
  }
  let balances = [];  // liste der kombinationen rechte/linke schale
  for (i = 0; i < candidates.length; i++)
    for (let j = 0; j < candidates.length; j++) {
      let tmp = candidates[i] + candidates[j];
      if (!tmp.hasDoubles())  // schonmal aussortieren
        balances.push([candidates[i], candidates[j]]);
    }
  // der plan ist folgender:
  // wir rechnen alle möglichen kombinationen durch und
  // übergeben die resultate in eine liste mit der form:
  // liste[zuMessendesGewicht] = [gewichteLinks, gewichteRechts].
  // hört sich aufwendig an, ist aber vertretbar aufgrund
  // der nun wesentlich geschrumpften kombinationsmöglichkeiten.
  let results = [];
  for (i = 0; i < balances.length; i++) {
    let lft = convert(balances[i][0]),
        rgt = convert(balances[i][1]),
        dif = rgt.sum() - lft.sum();
    if (dif >= 0) results[dif] = [lft, rgt];
  }
  // und wofür das ganze? nun, hierfür:
  return results[num];
}

// test
console.log( setOfScales1(50) );  // [2, 16, 32]
console.log( setOfScales2(50) );  // [ [1, 3, 27], [81] ]
                                  // lissalanda@gmx.at

                

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