Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Zusammenfassen von Listen (Felder)

Gegeben sind vier Listen mit Merkmalen

 

listeFarben      = ["blau", "gelb", "grün", "schwarz", "pink"]
listeNummern     = [1,2,3,4,5,6,7,8]
listeMaterialien = ["Beton", "Holz", "Stein"]
listeNamen       = ["Susi", "Klara", "Claire", "Moni"]

Schreibe ein Programm, das alle möglichen Kombination von drei Merkmalen in einer neuen Liste ausgibt.

Ausschnitt:

listeDrillingeKombination = [["blau", 1, "Beton"], ["blau", 2, "Beton"], ["blau", 3, "Beton"] ... , ["blau", 1, "Susi"], ["blau", 1, "Klara"], ..., ["gelb", 1, "Beton"], ...,[8, "Stein", "Moni"]]

0 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

4 Lösung(en)

package listenzusammenfassen;

/**
 * Zusammenfassen von Listen
 * Programmieraufgaben: Webcode: 	tnz2-iyeb
 * @version 0.1 (Dec 21, 2018)
 * @author Philipp Gressly Freimann 
 *         (phi@gress.ly)
 */
public class ZusammenfassenVonListen {

	public static void main(String[] args) {
		new ZusammenfassenVonListen().top();
	}

	String[] listeFarben      = {"blau", "gelb", "grün", "schwarz", "pink"};
	String[] listeNummern     = {"1", "2", "3", "4", "5", "6", "7", "8"};
	String[] listeMaterialien = {"Beton", "Holz", "Stein"};
	String[] listeNamen       = {"Susi", "Klara", "Claire", "Moni"};
	
	int anzahlZuBehandelndeListen = 3; // Der untenstehende Algorithmus funktioniert nur für "ListenAnzahl - 1"
	
	void top() {
		String[][] alleListen = {listeFarben, listeNummern, listeMaterialien, listeNamen};
		for(int ausgelassen = alleListen.length; ausgelassen --> 0;) {
			int[] listenIndizes = initialisierung(alleListen, ausgelassen);
			ausgabe(alleListen, listenIndizes);
		}
	}

	public int[] initialisierung(String[][] alleListen, int ausgelassen) {
		int[] listenIndizes = new int[alleListen.length - 1];
		int i = 0;
		String[][] aufgenommeneListen = new String[anzahlZuBehandelndeListen][];
		for(int aufgenommen = alleListen.length; aufgenommen -->0;) {
			if(aufgenommen != ausgelassen) {
				listenIndizes[i] = aufgenommen;
				aufgenommeneListen[i] = alleListen[aufgenommen];
				i++;
			}
		}
		return listenIndizes;
	}

	public void ausgabe(String[][] alleListen, int[] listenIndizes) {
		listenGenerator(alleListen, listenIndizes);
	}

	public void listenGenerator(String[][] ganzAlleListen, int[] listenIndizes) {
		String[][] alleListen = new String[listenIndizes.length][];

		for(int indexNummer = listenIndizes.length; indexNummer --> 0;) {
			alleListen[indexNummer] = ganzAlleListen[listenIndizes[indexNummer]];
		}
		listenGenerator(alleListen);
	}

	void listenGenerator(String[][] alleListen) {
		int[] auswahl = new int[alleListen.length];
		
		while(! isLast(auswahl, alleListen)) {
			ausgabeKurzArray(alleListen, auswahl);
			int rl = auswahl.length-1;
			while(auswahl[rl] == alleListen[rl].length-1) {
				rl--;
			}
			auswahl[rl] ++;
			for(int lr = rl+1; lr < auswahl.length; lr++) {
				auswahl[lr] = 0;
			}
		}
		ausgabeKurzArray(alleListen, auswahl);
	}

	boolean isLast(int[] auswahl, String[][] alleListen) {
		for(int pos = auswahl.length; pos --> 0;) {
			if(alleListen[pos].length-1 > auswahl[pos]) {
				return false;
			}
		}
		return true;
	}

	void ausgabeKurzArray(String[][] values, int[] indizes) {
		System.out.print("[");
		for(int i = 0; i < indizes.length; i++) {
			System.out.print(values[i][indizes[i]]);
			if(i < indizes.length - 1) {
				System.out.print(", ");
			}
		}
		System.out.println("]");
	}

} // end of class ZusammenfassenVonListen
                

Lösung von: Philipp Gressly Freimann (SANTIS Training AG)

import java.util.ArrayList;
import java.util.List;

public class Main {

    private final static String[] colors = {"blau", "gelb", "grün", "schwarz", "pink"};
    private final static int[] nums = {1, 2, 3, 4, 5, 6, 7, 8};
    private final static String[] materials = {"Beton", "Holz", "Stein"};
    private final static String[] names = {"Susi", "Klara", "Claire", "Moni"};

    public static void main(String[] args) {
        List<List> listTriples = new ArrayList<List>();

        intCombi(colors, names, listTriples); //Alle Kombinationen von drei Merkmalen aus den übergebenen Listen und der Nummer-Liste.
        intCombi(materials, names, listTriples);
        intCombi(colors, materials, listTriples);

        //Alle Kombinationen von drei Merkmalen aus der Namen-Liste, Farben-Liste und Material-Liste.
        for (String name : names) {
            for (String color : colors) {
                for (String material : materials) {
                    List newTriple = new ArrayList();
                    newTriple.add(name);
                    newTriple.add(color);
                    newTriple.add(material);
                    listTriples.add(newTriple);
                }
            }
        }

        for (List l : listTriples) {
            System.out.println(l);
        }
        System.out.println("Anzahl Kombinationen: " + listTriples.size());
    }

    private static void intCombi(String[] listOne, String[] listTwo, List listTriples) {
        for (int num : nums) {
            for (String stringOne : listOne) {
                for (String stringTwo : listTwo) {
                    List newTriple = new ArrayList();
                    newTriple.add(num);
                    newTriple.add(stringOne);
                    newTriple.add(stringTwo);
                    listTriples.add(newTriple);
                }
            }
        }
    }
}

                

Lösung von: Daniel Figia (Technische Hochschule Lübeck)

(ns programmieraufgaben.core
  (:require [clojure.math.combinatorics :as combinatorics])
  (:gen-class))

(def listeFarben (list "blau" "gelb" "grün" "schwarz" "pink"))
(def listeNummern (list 1 2 3 4 5 6 7 8))
(def listeMaterialien (list "Beton" "Holz" "Stein"))
(def listeNamen (list "Susi" "Klara" "Claire" "Moni"))
(defn combi [a b c] (for [i a j b k c] (list i j k)))
(defn applycombi [items] (map #(apply combi %) items))
(defn flatten-one-level [coll]  
    (mapcat  #(if (sequential? %) % [%]) coll))

(defn -main
  [& args]
  (-> (list listeFarben listeNummern listeMaterialien listeNamen)
    (#(combinatorics/combinations % 3))
    applycombi
    flatten-one-level
    println))
                

Lösung von: André Trobisch ()

#!/usr/bin/python3.6

import itertools

lists = {
    'listeFarben'     : ["blau", "gelb", "grün", "schwarz", "pink"],
    'listeNummern'    : [1,2,3,4,5,6,7,8],
    'listeMaterialien': ["Beton", "Holz", "Stein"],
    'listeNamen'      : ["Susi", "Klara", "Claire", "Moni"]
}

def combinations(list1, list2, list3):
    combinations = []
    for entry1 in list1:
        for entry2 in list2:
            for entry3 in list3:
                combinations.append([entry1, entry2, entry3])
    return combinations

result = []
for tuple in itertools.combinations(lists.keys(), 3):
    for combination in combinations(lists[tuple[0]], lists[tuple[1]], lists[tuple[2]]):
        result.append(combination)

print(result)


                

Lösung von: Name nicht veröffentlicht

Verifikation/Checksumme:

Total kommen 436 Tripel vor (5*8*3 + 5*8*4 + 5*3*4 + 8*3*4).

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 1
Schwierigkeit: Mittel
Webcode: tnz2-iyeb
Autor: ()

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen