Programmierschwierigkeit

[desperado2000]

Auf einem Snooker-Tisch befinden sich 15 rote Kugeln und jeweils eine gelbe, grüne, braune, blaue, pinke und schwarze Kugel. Diese werden auch farbige Kugeln genannt. Die roten Kugeln haben die Wertigkeit 1 und die Farbigen die Wertigkeit 2 bis 7 (in der genannten Reihenfolge). Ziel von Snooker ist es, so viele Kugeln wie möglich hintereinander einzulochen. Dabei muss abwechselnd immer eine rote gefolgt von einer farbigen Kugel gespielt werden. Die Farbigen werden nach dem Lochen wieder auf den Tisch zurückgelegt.

Als Eingabe wird eine mögliche Punktzahl übergeben. Geben Sie alle Varianten der Reihenfolgen an, in welchen die Kugeln eingelocht werden müssen, um genau diese Punktzahl zu erreichen. Dabei sollen die Permutationen von möglichen Reihenfolgen nur einmal berücksichtigt werden.

z.B.: Eingabe = 8
rot schwarz
rot pink rot
rot braun rot gelb
rot gelb rot braun !!! Diese Permutation nicht anzeigen !!!
...

------------------------
Beispiel

Ich würde gerne die 7 spielen.
Also gibts 1 Möglichkeit 1-6
1-2-1-3
1-5-1
Sodele würdet ihr als Algo die 6 zerlegen und 4 2, 3 3,1-5 usw?
Oder habt ihr einen besseren Algo?

Würde mich freuen wenn ihr mir helft.
Mit freundlichem Gruß

[Coda]

Das lässt sich echt einfach per Rekursion lösen.

[desperado2000]

Kann ja sein das es echt einfach ist aber wenn man weiss wie es geht ist es sicher einfach.
Könntest du mir eine kleine Starthilfe geben?Quasi eine Initialzündung geben?

Danke

[Coda]

Du schreibst einfach eine Funktion der du den derzeitigen Wert und die schon verwendeten Kugeln übergibst.

Diese ruft sich dann solange selbst mit allen Permutationen auf bis sie eine Lösung gefunden hat oder abbricht.

[ethrandil]

Ich verstoße mal eben gegen die Hausaufgabenregel, aber... ich bin halt Angeber xD (code ist aber suboptimal)


(define *kugeln* '((gelb 2)
(grün 3)
(braun 4)
(blau 5)
(pink 6)
(schwarz 7)))
(define *problem* (list (list 8 '() *kugeln*)))

(define (snooker zustände)
(cond
[(null? zustände) '()]
[(= 0 (caar zustände)) (cons (cadar zustände) (snooker (cdr zustände)))]
[else (snooker (append (nachfolger (car zustände)) (cdr zustände)))]))

(define (nachfolger zustand)
(define (_nachfolger zahl drin kugeln)
(cond
[(or (< zahl 0) (null? kugeln)) '()]
[(or (null? drin) (not (equal? (car drin) 'rot)))
(list (list (- zahl 1) (cons 'rot drin) kugeln))]
[else (cons (list
(- zahl (cadar kugeln))
(cons (caar kugeln) drin)
(cdr kugeln))
(_nachfolger zahl drin (cdr kugeln)))]))

(_nachfolger (car zustand) (cadr zustand) (caddr zustand)))

(snooker *problem*);)

- Eth

(EDIT: schön hübscher...)

[Coda]

Ist das LISP oder Scheme? Btw. der Threadersteller hat gar nicht gesagt in welcher Sprache das ganze sein soll...

Edit: Ok es ist LISP. "caddr" :crazy:

[Gast]

Du schreibst einfach eine Funktion der du den derzeitigen Wert und die schon verwendeten Kugeln übergibst.

Diese ruft sich dann solange selbst mit allen Permutationen auf bis sie eine Lösung gefunden hat oder abbricht.

Rekursiv also :-)
ja sehr einfach ;-)