Se pueden meter jars dentro de otros jars. Pero no queréis, ya os lo digo yo.

Jars en la carpeta lib y un classpath correcto, eso es todo lo que hace falta. Algunos IDEs te lo hacen automático.

Nada, esto es lo mejor que he conseguido después de un buen rato, yo creo que así lo voy a dejar...



Si a alguien le apetece practicar y no sabe con que ya tiene algo

Los detalles en python los desconozco, pero lo que quieres hacer es compilación cruzada. Busca cómo hacer compilación cruzada de python y ya está.

http://www.google.com/search?q=python+cross+compile

Por llamarlo de alguna forma, realmente no sé cómo se llama, y por tanto no he buscado en internet, mis disculpas. A ver si alguien tiene un tutorial o alguna explicación, porque esto del photoshop es interesante pero sé lo justo:

Este es el original:



Esta es la imagen modificada:


Si no pudiera ser también me vale así, aunque es mucho peor:



Muchas gracias.

Bueno, el problema que quería resolver era más complicado, porque además quería generarlos de uno en uno sin guardar los resultados parciales, cosa que ya he hecho, pero como es una restricción que no había contemplado y el código queda un poco más complicado he decidido hacer también la versión normal, es decir, almacenando resultados parciales hasta que se devuelven todos.

def lattice(l):
  s = [[]]
  for e in l:
    ns = []
    for ps in s:
      nps = ps[:]
      nps.append(e)
      ns.append(nps)
    s = s + ns
  return s

PD: do-while en las combnaciones no importa el orden, importa en las variaciones.
ghastlyX sí, también lo puedes ver como la unión de las particiones de un conjunto.

PD2: no se me había ocurrido hacerlo recursivo, no queda del todo mal:

def lattice(l):
  if l == []:
    return [[]]
  ll = lattice(l[1:])
  return [e+[l[0]] for e in ll] + ll

Tengo que hacer todas las posibles combinaciones de una lista (cuidado, he dicho combinaciones, no permutaciones), esto significa las combinaciones tomadas de uno en uno de todos los elementos de la lista (es decir, sus elementos), de dos en dos, y así hasta las combinaciones de n en n elementos siendo n la longitud de  la lista, es decir, sólo habrá una combinación de ese tamaño.

Lo estoy programando en python, así que si no me distraen mucho pondré la solución en ese lenguaje dentro de poco, pero puede ser un ejercicio interesante también para otros lenguajes.

lo mejor para xml en java es xmlbeans, y no, no he visto lo que puedes hacer y lo que no. Si haces referencia a otro mensaje qué menos que poner un enlace...

En python:

palindromo = lambda s: s[:len(s)//2] == s[:(len(s)-1)//2:-1]

Pensándolo mejor, no lo voy a ampliar más, también es un ejercicio interesante, pero es algo más complicado que lo otro y no me merece la pena para lo que quiero hacer. Vamos, que llevo ya un rato para lo otro, en parte por enfocarlo mal, si lo hubiera hecho con backtracking desde el principio ya habría terminado, y hasta aquí el tiempo que quiero dedicar.

  def factorization(k):
    s = 2
    fs = []
    for j in range(s, int(k ** (1/2))+1):
      while (k%j == 0):
        fs.append(j)
        k = k // j
    if (k != 1):
      fs.append(k)
    return fs

Por cosas de la vida me viene bien tener un algoritmo para hacer la descomposición factorial de un número y lo voy a hacer ahora en python.

Puede ser un ejercicio interesante, es como el típico de hallar los números primos pero ampliándolo con algo más.

Personalmente lo voy a ampliar (más) después a hallar el mínimo número de factores del número original, teniendo de los m factores m+0.5/2 que sean menores de 26 y m/2 menores de 5, para formar palabras. Pero eso ya lo dejo a lo que quiera hacer cada uno.

Dentro de un rato pongo el código, si no me interrumpen.