La respuesta a esta pregunta es demasiado larga.

Su desafío es escribir una función de partición en el menor número de caracteres.

Ejemplo de entrada

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

Ejemplo de salida

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

La entrada puede ser una lista / matriz / conjunto / cadena, etc., lo que sea más fácil de procesar para su función

También puede elegir el formato de salida que más le convenga siempre que la estructura sea clara.

Su función debería funcionar para al menos 6 elementos en la entrada

GolfScript (43 caracteres)

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

o

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

Mismo formato de entrada, formato de salida y nombre de función que la solución de Howard. No hay forzamiento bruto: esto toma el enfoque iterativo simple de agregar un elemento de la lista de entrada a la partición cada vez que se rodea el bucle externo.

GolfScript, 51 caracteres

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

El script define una variable Pque toma una matriz de la parte superior de la pila y empuja hacia atrás una lista de todas las particiones, p. Ej.

[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"]]]

También funciona en listas más grandes:

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

Puede realizar sus propias pruebas en línea .

J, 51 caracteres

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

Toma información del teclado, elementos separados por espacios:

   ([:<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

Guardado 5 bytes gracias a nimi .

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

Ejemplo:

*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

Pruébalo en línea

Utiliza este algoritmo .