Test auf Dopplungen

[DerAhnungsloseDude]

Hey liebe Forenmitglieder ,
ich steh vor der Aufgabe die wie folgt lautet:

Man soll aus einer Eingabe x(<=1000) , x Zeilen folgen lassen , welche mindestens 2 Wörter und max.1000 Zeichen besitzen.
Wobei das erste Worte ein Name darstellt und die weiteren Wörter Pizzabeläge.
Wenn 2 Namen die selben Pizzabeläge favorisieren können die sich quasi eine teilen.
Also folgendes Beispiel:
x=5
Michael Mais Käse Schinken
Andi Paprika Mais Salami
Sandra Sahne Schinken Käse
Sonja Mais Käse Schinken
Chris Mais Käse Schinken
Daraus sollte das Programm die Anzahl der verschiedenen Pizzen ausgeben.In diesem Fall also 3.(Hoffe ist verständlich)
Nun zu meinen Code

import java.util.Scanner;
public class Pizzabelag {
public static void main(String[]args) {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    
    if(n<=1000) {
        for(int i=0;i<=n;i++) {
            String text=sc.nextLine();
            String a=new String(text);
            while(a.length()>=1 && a.length()<=1000) {
                    //????
                
            }
        }
        
    }
}
}

Ich glaube es bis zur Eingabe der einzelnen Worte hinbekommen zu haben.Nun weiß ich leider nicht wie ich es auf Gleichheit prüfen soll. :/
Für Ideen & Tipps wäre ich sehr dankbar.

 

[Tarrew]

Am besten speicherst du deine Daten erstmal in irgendeiner objektorientierten Struktur.
(Was soll überhaupt dein String "a" und die while-Schleife darunter machen? Die erscheinen mir ziemlich sinnlos).

Also, deine Pizzen könnte man so speichern:

Spoiler

public class Test {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.nextLine();

        List<Pizza> pizzas = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            String[] sPizza = sc.nextLine().split(" ");
            pizzas.add(new Pizza(sPizza[0], Set.of(Arrays.copyOfRange(sPizza, 1, sPizza.length))));
        }

        System.out.println(pizzas);
    }

}

class Pizza {
    private String customer;
    private Set<String> toppings; //Jedes Topping nur 1x erlaubt in diesem Beispiel, Reihenfolge der Toppings spielt keine Rolle

    public Pizza(String customer, Set<String> toppings) {
        this.customer = customer;
        this.toppings = toppings;
    }

    public String getCustomer() {
        return customer;
    }

    public void setCustomer(String customer) {
        this.customer = customer;
    }

    public Set<String> getToppings() {
        return toppings;
    }

    public void setToppings(Set<String> toppings) {
        this.toppings = toppings;
    }

    @Override
    public String toString() {
        return "Pizza{" +
                "customer='" + customer + '\'' +
                ", toppings=" + toppings +
                '}';
    }
}

Und jetzt überlegst du dir wie man Objekte auf Gleichheit überprüft. Und wie macht man das? Richtig, mit der equals-Methode. Wenn du die equals-Methode der Klasse "Pizza" schlau überschreibst und das mit einem Set verbindest (lies dir mal die Eigenschaften eines Set's durch, falls du die nicht kennst), dann kommst du schnell an deine Lösung

 

[Xyz1]

x=5 kannst Du ja schon einlesen, also fehlt noch:

import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Objects;
import java.util.Random;

public class Pizza {
    HashMap<Integer, LinkedList<Integer>> BelagPersonenCombo = new HashMap<>();

    void add(Random r) {
        int z1 = r.nextInt(Belag.values().length);
        int z2 = r.nextInt(Belag.values().length);
        if (z1 > z2) {
            int i = z1;
            z1 = z2;
            z2 = i;
        }
        int k = Objects.hash(z1, z2);
        int v = r.nextInt(Person.values().length);
        if (BelagPersonenCombo.containsKey(k)) {
            BelagPersonenCombo.get(k).add(v);
        } else {
            BelagPersonenCombo.put(k, new LinkedList<>(Arrays.asList(z1, z2, v)));
        }
    }

    public static void main(String[] args) {
        int n = 5;
        Random r = new Random(16);
        Pizza pizza = new Pizza();
        for (int i = 0; i < n; i++) {
            pizza.add(r);
        }

        for (LinkedList<Integer> l : pizza.BelagPersonenCombo.values()) {
            System.out.println("Folgende Personen essen gerne " + Belag.values()[l.get(0)] + " und " + Belag.values()[l.get(1)] + ":");
            for (Integer i : l.subList(2, l.size())) {
                System.out.println(Person.values()[i]);
            }
            System.out.println();
        }
    }
}

enum Person {
    Michael, Andi, Sandra, Sonja, Chris, Tobias, Foo, Bar, Baz
}

enum Belag {
    Mais, Käse, Schinken, Salami, Sahne, Brokkoli, Bolognese, Artischocken, Mozarella, Zwiebel, Paprika, Lauch
}

(Ich habe Mozarella falschgeschrieben )

 

[httpdigest]

Daraus sollte das Programm die Anzahl der verschiedenen Pizzen ausgeben.In diesem Fall also 3.

Falls nur die Anzahl gewünscht ist, dann:

public class Pizza {
  private static long anzahlVerschiedenerPizzen(
      java.util.stream.Stream<java.util.stream.Stream<String>> belaege) {
    return belaege
      .map(s -> s.map(String::toLowerCase)
                 .sorted()
                 .collect(java.util.stream.Collectors.joining()))
      .distinct()
      .count();
  }
  private static java.util.stream.Stream<java.util.stream.Stream<String>>
                 pizzaBestellungen(java.util.Scanner sc) {
    return java.util.stream.IntStream
      .range(0, Integer.parseInt(sc.nextLine()))
      .mapToObj(__ -> sc.nextLine())
      .map(line -> line.split("\\s+"))
      .map(words -> java.util.Arrays.stream(words).skip(1));
  }
  public static void main(String[] args) {
    java.util.Scanner sc = new java.util.Scanner(System.in);
    long anzahl = anzahlVerschiedenerPizzen(pizzaBestellungen(sc));
    sc.close();
    System.out.println("Anzahl unterschiedlicher Pizzen: " + anzahl);
  }
}

 

[Xyz1]

Ach Mist, da können Hash-Kollisionen auftreten, die dann dazu führen, dass eine Person eine Pizza bekommt, die sie gar nicht mag - oder eine Person kann zB auch als Belag zweimal Lauch bekommen...

 

[Xyz1]

Falls nur die Anzahl gewünscht ist, dann

Und wo wären deine vorgegebenen Beläge?

 

[White_Fox]

Mensch, einmal mit Profis arbeiten...

 

[Xyz1]

Mensch, einmal mit Profis arbeiten...

Wie im richtigen Leben halt! ... Darauf mal einen Schnaps.

 

[White_Fox]

Da bin ich dabei.
Ваше здоровье!

 

[Xyz1]

Schade das mihe7 nicht dabei ist.

Spoiler

 

[White_Fox]

Ich glaub ich hab ihn mit meiner Problembeschreibung im Nachbarforum zu sehr beschäftigt. Wenn ich so drüber nachdenk: Ich weiß gar nicht ob ich nüchtern war als ich mir das ausgedacht habe...

 

[Der Wissende]

(Ich habe Mozarella falschgeschrieben )

Und auch die Aufgabe falsch verstanden... Es sollen n Zeilen eingelesen werden die aus PERSON und BELAG+ bestehen. Dann soll geschaut werden wie viele verschiedene Pizzen es gibt.
Du generierst Random Pizzen mit 2 verschiedenen Zutaten, packst sie in eine Map mit Personen, und gibst sie dann aus.

@httpdigest hat ja schon eine Lösung mit Streams geschrieben, die super ist. Hier nochmal eine anfängerfreundlichere:

import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class Pizza {

  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    
    int anzahl = sc.nextInt();
    sc.nextLine();
    
    //Hier speichern wir die Pizzen als Set, sollen ja keine doppelten vorkommen
    Set<Set<String>> pizzen = new HashSet<>();
    
    for(int i=0;i<anzahl;i++) {
      String line = sc.nextLine();
      //Zeile in einzelne Wörter zerteilen
      String[] splitted = line.split(" ");
      //Das erste Wort ist der Name, uns interessiert nur das was danach kommt
      String[] toppings = Arrays.copyOfRange(splitted, 1, splitted.length);
      //Da doppelte Zutaten nicht erlaubt sein sollten und auch die Reihenfolge egal ist, packen wir die Zutaten in ein Set
      HashSet<String> toppingsAsSet = new HashSet<>(Arrays.asList(toppings));
      //Dann fügen wir die Zutaten den Pizzen hinzu
      pizzen.add(toppingsAsSet);
    }
    // In den Pizzen stehen jetzt nur noch die Zutaten, die einfach vorkommen. Daher ist die Lösung einfach die größe des Sets
    System.out.print(pizzen.size());
  }
}

 

[Xyz1]

Es sollen n Zeilen eingelesen werden die aus PERSON und BELAG+ bestehen

Das erscheint mir ziemlich unsinnig.

Dann soll geschaut werden wie viele verschiedene Pizzen es gibt

Das macht schon mehr Sinn.

 

[Xyz1]

Oder eben rein mathematisch:

public static void main(String[] args) {
	Scanner sc = new Scanner(System.in);
	System.out.println("Wie viele Beläge gibt es?");
	int n1 = sc.nextInt();
	System.out.println("Wie viele Beläge gibt es pro Pizza?");
	int n2 = sc.nextInt();
	System.out.println("Wie viele Personen gibt es?");
	int n3 = sc.nextInt();
	long n4 = fac(n1) / (fac(n1 - n2) * fac(n2));
	System.out.println("Es gibt " + n4 + " mögliche Pizzen.");
	double n5 = (1.0 - (Math.pow(1.0 / n4, n3) * n4)) * 100.0;
	System.out.println("Mit einer Wahrscheinlichkeit von " + (float) n5 + " mögen zwei Personen die gleiche Pizza.");
}

public static long fac(int i) {
	long l = 1;
	while (i > 0) {
		l *= i--;
	}
	return l;
}

(n5 könnte falsch sein...)

 

[kneitzel]

Das erscheint mir ziemlich unsinnig.

Aber laut Anforderung war genau dies gefordert:
"Man soll aus einer Eingabe x(<=1000) , x Zeilen folgen lassen , welche mindestens 2 Wörter und max.1000 Zeichen besitzen.
Wobei das erste Worte ein Name darstellt und die weiteren Wörter Pizzabeläge."

 

[Xyz1]

Moin kneitzel,

double n5 = (1.0 - (Math.pow(1.0 / n4, n3) * n4)) * 100.0;

weißt Du zufällig was hieran falsch ist? ( https://123mathe.de/mehrstufige-zufallsversuche )

Ich knobele jetzt schon länger daran... erfolglos

 

[Der Wissende]

Das erscheint mir ziemlich unsinnig.

Bei dir wäre ich gern mal auf einer Party eingeladen.
Alle anderen so: "He ich hab da einen Zettel liegen schreibt doch mal alle drauf auf was für eine Pizza ihr Bock habt." bisschen später "ah okay ich bestell dann mal 10 verschiedene Pizzen"
Du: "schön das ihr alle gekommen seid, ich hab mal Pizza bestellt, ich hab berechnet, dass mit einer Wahrscheinlichkeit von 30% hat jemand Lust auf Käse mit Mozzarella und Sahne hat"

weißt Du zufällig was hieran falsch ist?

Du meinst neben der Themenverfehlung?

Also wir stellen uns jetzt einfach mal vor das wir auf der Party von @Tobias-nrw sind und Tobias hat jetzt mal was vorbereitet. Er hat festgelegt, dass es 10 verschiedene Zutaten für Pizza gibt und das jede Pizza genau 3 Zutaten haben darf. Also gibt es keine Margarita und keine quattro Formaggi.
Da er ja ein Fuchs ist bestellt er nun mal alle 120 möglichen Pizzen. Jetzt kommen seine Freunde DerWissende, horstiii und horstiii2. Jeder darf sich eine Pizza aussuchen. Die Wahrscheinlichkeit das sich jemand die Käse-Morzzarella-Sahne Pizza aussucht liegt bei 1/120. Dass sich 2 Leute die gleiche Pizza aussuchen liegt bei (1/120 * 1/120) und dass sich dann n Leute die gleiche Pizza aussuchen liegt bei 1/120 ^ n. Dass jetzt genau 2 Leute die gleiche Pizza wollen liegt bei (1/120)^Anzahl der möglichen Paare. Also in unserem Fall (1/120)^((3!/((3-2)!*2!)) = 5,78703704 × 10^-7

 

[mihe7]

Es gibt b Beläge und p Beläge/Pizza (Pizzabelag). Wie viele Möglichkeiten m gibt es, p Pizzabeläge aus b Belägen auszuwählen? m = b!/(p!*(b-p)!)

Die Anzahl an Kombinationen von n Personen und Pizzen ist also m^n.

Wie hoch ist die Wahrscheinlichkeit, dass sich z. B. 2 Personen unterschiedliche Pizzen aussuchen? Naja, die erste Person hat m Möglichkeiten, für die zweite bleiben dann noch m-1 übrig usw. Für n Personen gilt also u(m,n) = m(m-1)*...(m-n+1)

Die Wahrscheinlichkeit, dass die von n Personen ausgewählten Pizzen unterschiedlich sind, beträgt: Pv = u(m,n)/(m^n). D. h. die Wahrscheinlichkeit, dass wenigstens zwei Personen die gleiche Pizza wählen, liegt bei Pg=1-Pv

Für n = 3, b = 10, p = 3 ergibt sich:

m = 120
u(m,n) = 120*119*118 = 1685040
Pv = 1685040 / 1728000 ~ 97,5 %
Pg = 1 - Pv = 2,5 %

 

[Xyz1]

@Der Wissende Wenn man keine Antwort hat, muss man nicht antworten. Auch nicht mit BS oder Flamewars...

Das ist Kindergartengealbere und an der Aufgabe vorbei...

@ all Falls ihr wisst, was an der Formel falsch ist, bitte schreiben.

 

[mihe7]

Dass sich 2 Leute die gleiche Pizza aussuchen liegt bei (1/120 * 1/120) und dass sich dann n Leute die gleiche Pizza aussuchen liegt bei 1/120 ^ n.

Dann wäre die Wahrscheinlichkeit, dass sich 2 Leute die gleiche Pizza aussuchen, bei 1000 Leuten kleiner als bei 2...

 

[Xyz1]

u(m,n) = m(m-1)*...(m-n+1)

Das ist nicht die Fakultät und auch nicht n über k - oder?

 

[mihe7]

Wenn ich mich nicht verschaut habe, sollte das m!/(m-n)! sein.

 

[Xyz1]

Stimmt leider nicht.

for (int j = 1; j < 5; j++) {
	for (int i = j; i < 10; i++) {
		int n1 = i;
		int n2 = 1;
		int n3 = j;
		System.out.println("Es gibt " + n3 + " Personen.");
		long n4 = fac(n1) / (fac(n1 - n2) * fac(n2));
		System.out.println("Es gibt " + n4 + " mögliche Pizzen.");
		double n5 = (double) fac((int) n4) / fac((int) n4 - n3);
		System.out.println("Mit einer Wahrscheinlichkeit von " + (float) n5 + " mögen zwei Personen die gleiche Pizza.");

		int x = 0;
		for (int l = 0; l < 1000; l++) {
			boolean b = false;
			int[] ii = new int[(int) n4];
			for (int k = 0; k < n3; k++) {
				ii[new Random().nextInt(ii.length)]++;
			}
			for (int k = 0; k < ii.length; k++) {
				if (ii[k] >= 2) {
					b = true;
				}
			}
			if (b) {
				x++;
			}
		}
		System.out.println(x / 1000.0);
	}
}

 

[Xyz1]

@Der Wissende Es liegt durchaus "in der Natur der Pizzerien", dass bei mehreren Personen, einzelne eine Pizza bekommen, die sie gar nicht bestellt haben. Diese Wahrscheinlichkeit steigt mit der Anzahl der Personen.

Es ist also kein realitätsferner Quatsch und indirekt hatte der TE auch danach gefragt.

Deswegen verstehe ich nicht, warum Du jetzt so einen Dackel davon machst...

 

[DerAhnungsloseDude]

@Tobias-nrw nene @Der Wissende hatte mit seiner Interpretation der geforderten Aufgabenstellung vollkommen recht. Es ist nur gesucht wie viele unterschiedlichen Pizzen nach den Eingaben vorliegen.

 

[Xyz1]

Schade keine (intellektuelle) Herausforderung. Ja dann Beitrag #3 oder Beitrag #4 von @httpdigest .

 

[DerAhnungsloseDude]

@Tobias-nrw manchmal ist es auch angenehmer nicht zu weit aus der Ausgaben hinaus zu interpretieren zu müssen .
Ja es tut es soll , fande aber zum verstehen vorallem zum nachvollziehen den Beitrag von @Der Wissende deutlich besser.

 

[mihe7]

Stimmt leider nicht.

Du hast ja auch die Hälfte weggelassen; dein n5 berechnet nur u(m,n), wenn ich es richtig sehe.

 

[Xyz1]

dein n5 berechnet nur u(m,n), wenn ich es richtig sehe

Danke dennoch.

 

[mihe7]

double n6 = 1.0 - n5 / Math.pow(n4, n3);

dürfte dann die Wahrscheinlichkeit sein...

 

[Xyz1]

@mihe7 Du Verrückte/r... Das funktioniert, solange es nicht mehr Personen als Pizzen gibt:

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("Wie viele Beläge gibt es?");
		int n1 = sc.nextInt();
		System.out.println("Wie viele Beläge gibt es pro Pizza?");
		int n2 = sc.nextInt();
		System.out.println("Wie viele Personen gibt es?");
		int n3 = sc.nextInt();
		long n4 = fac(n1) / (fac(n1 - n2) * fac(n2));
		System.out.println("Es gibt " + n4 + " mögliche Pizzen.");
		double n5 = (double) fac((int) n4) / (double) fac((int) n4 - n3);
		double n6 = 1.0 - n5 / Math.pow(n4, n3);
		System.out.println("Mit einer Wahrscheinlichkeit von " + (float) n6 + " bekommen zwei Personen die gleiche Pizza.");
	}

	public static long fac(int i) {
		long l = 1;
		while (i > 0) {
			l *= i--;
		}
		return l;
	}

Wie viele Beläge gibt es?
5
Wie viele Beläge gibt es pro Pizza?
3
Wie viele Personen gibt es?
6
Es gibt 10 mögliche Pizzen.
Mit einer Wahrscheinlichkeit von 0.8488 bekommen zwei Personen die gleiche Pizza.

 

[mihe7]

Das funktioniert, solange es nicht mehr Personen als Pizzen gibt:

Ja, dann beträgt die Wahrscheinlichkeit 100 %.

 

[Xyz1]

Es müssen sich Pizzen geteilt werden logisch.