Die Antwort auf diese Frage ist viel zu lang

Ihre Herausforderung besteht darin, eine Partitionierungsfunktion mit der geringsten Anzahl von Zeichen zu schreiben .

Eingabebeispiel

['a', 'b', 'c']

Ausgabebeispiel

[(('a'),('b'),('c')),
 (('a', 'b'), ('c')),
 (('a', 'c'), ('b')),
 (('b', 'c'), ('a')),
 (('a', 'b', 'c'))]

Die Eingabe kann eine Liste / ein Array / eine Menge / eine Zeichenfolge usw. sein, was für Ihre Funktion am einfachsten zu verarbeiten ist

Sie können auch das Ausgabeformat auswählen, das zu Ihnen passt, solange die Struktur klar ist.

Ihre Funktion sollte für mindestens 6 Elemente in der Eingabe funktionieren

GolfScript (43 Zeichen)

{[[]]:E\{:v;{:^E+1/{^1$-\[~[v]+]+}/}%}/}:P;

oder

{[[]]:E\{:v;{:^E+1/{^1$-\{[v]+}%+}/}%}/}:P;

Gleiches Eingabeformat, Ausgabeformat und Funktionsname wie bei Howard. Es gibt kein brutales Forcen: Dies erfordert den einfachen iterativen Ansatz, jedes Mal um die äußere Schleife ein Element aus der Eingabeliste zur Partition hinzuzufügen.

GolfScript, 51 Zeichen

{[[]]\{[.;]`{1$[1$]+@@`1$`{[2$]-@@[+]+}++/}+%}/}:P;

Das Skript definiert eine Variable, Pdie ein Array vom oberen Rand des Stapels nimmt und eine Liste aller Partitionen zurückschiebt, z

[1 2] P            # => [[[1] [2]] [[1 2]]]
["a" "b" "c"] P    # => [[["a"] ["b"] ["c"]] [["b"] ["a" "c"]] [["a"] ["b" "c"]] [["a" "b"] ["c"]] [["a" "b" "c"]]]

Es funktioniert auch bei größeren Listen:

6, P ,p            # prints 203, i.e. Bell number B6
8, P ,p            # 4140

Sie können eigene Tests online durchführen .

J, 51 Zeichen

([:<a:-.~])"1~.((>:@i.#:i.@!)#l)<@;/."1[l=:;:1!:1[1

Übernimmt Eingaben über die Tastatur, Elemente durch Leerzeichen getrennt:

   ([:<a:-.~])"1~.((>:@i.#:i.@!)#l)<@;/."1[l=:;:1!:1[1
a b c
+-----+------+------+------+-------+
|+---+|+--+-+|+--+-+|+-+--+|+-+-+-+|
||abc|||ab|c|||ac|b|||a|bc|||a|b|c||
|+---+|+--+-+|+--+-+|+-+--+|+-+-+-+|
+-----+------+------+------+-------+

Haskell, 90 87 71 66

5 Bytes dank Nimi gespeichert .

x#[]=[[[x]]]
x#(y:s)=((x:y):s):map(y:)(x#s)
p=foldr((=<<).(#))[[]]

Beispiel:

*Main> p "abc"
[["abc"],["bc","a"],["ac","b"],["c","ab"],["c","b","a"]]

Python 2, 131 Bytes

def P(L):
 if len(L)<2:yield[L];return
 for p in P(L[1:]):
	for n,s in enumerate(p):yield p[:n]+[[L[0]]+s]+p[n+1:]
	yield[[L[0]]]+p

Probieren Sie es online aus

Verwendet diesen Algorithmus .