Programmieren lernen

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 G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

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

import itertools
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 new_combs(*lists, n):
    for x in itertools.combinations(lists, n):
        yield from itertools.product(*x)
print(list(new_combs(listeFarben, listeNummern, listeMaterialien, listeNamen, n=3)))
                

Lösung von: Name nicht veröffentlicht

let lists = [
    'blau gelb grün schwarz pink'.split(' '),
    [1, 2, 3, 4, 5, 6, 7, 8],
    'Beton Holz Stein'.split(' '),
    'Susi Klara Claire Moni'.split(' ')
  ],
  // könnte man auch generieren, aber für heute langt's schon:
  index = [[0,1,2], [0,1,3], [0,2,3], [1,2,3]],
  x, i, j, k,
  out = [];

for (x in index)
  for (i in lists[index[x][0]])
    for (j in lists[index[x][1]])
      for (k in lists[index[x][2]])
        out.push([
          lists[index[x][0]][i], lists[index[x][1]][j], lists[index[x][2]][k]
        ]);

console.log(out);

                

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