El acertijo numérico de Aristóteles es el desafío de poblar cada una de las 19 celdas en una cuadrícula hexagonal con un número entero único entre 1 y 19, de modo que el total a lo largo de cada eje sea 38.

Puedes imaginar el tablero de juego de esta manera:

Y el rompecabezas, en esencia, es la solución al siguiente conjunto de quince ecuaciones:

((a + b + c) == 38 && (d + e + f + g) == 38 && (h + i + j + k + l) == 
   38 && (m + n + o + p) == 38 && (q + r + s) == 38 && (a + d + h) == 
   38 && (b + e + i + m) == 38 && (c + f + j + n + q) == 
   38 && (g + k + o + r) == 38 && (l + p + s) == 38 && (c + g + l) == 
   38 && (b + f + k + p) == 38 && (a + e + j + o + s) == 
   38 && (d + i + n + r) == 38 && (h + m + q) == 38)

Donde cada variable es un número único en el conjunto {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19}.

Existen múltiples soluciones posibles, y son 19!posibles combinaciones de enteros, por lo que la fuerza bruta ingenua no será práctica.

Reglas:

1. Sin codificar la respuesta o buscar la respuesta en otra parte; su código necesita encontrarlo solo
2. La velocidad no importa, pero debe mostrar sus resultados, por lo que el código que tarda 1000 años en ejecutarse no lo ayudará
3. Encuentra todas las respuestas
4. Trate las respuestas que son idénticas en rotación como idénticas
5. Deduzca el 5% de su recuento total de bytes si genera los resultados en un atractivo panal
6. Pocos bytes ganan

Haskell 295 289

import Data.List
t=38
y a b=[max(19-b)(a+1)..19]
w=y 0 t
x=filter((==w).sort)$[[a,b,c,d,e,f,g,h,i,t-a-e-o-s,k,l,m,t-d-i-r,o,p,q,r,s]|a<-[1..14],c<-y a a,l<-y a c,s<-y a l,q<-y a s,h<-y c q,e<-w,let{f=t-g-e-d;i=t-b-e-m;o=t-r-k-g;k=t-p-f-b;b=t-a-c;g=t-l-c;p=t-l-s;r=t-q-s;m=t-q-h;d=t-a-h}]

Otra respuesta similar, usando la aritmética para obtener los hexes intermedios. A diferencia de las otras soluciones, no pruebo que esas sumas sean> 0, es suficiente probar que los hexes ordenados son iguales al rango [1..19]. a, c y h están restringidos, de modo que solo se permiten soluciones rotadas / duplicadas de forma única. La solución aparece después de unos segundos, luego hay que esperar un minuto más o menos mientras decide que no hay más.

Uso en ghci:

ghci> x
[[3,19,16,17,7,2,12,18,1,5,4,10,11,6,8,13,9,14,15]]

Editado para afeitarse algunos caracteres. 'y 0 t' produce [1..19].

Java (1517 - 75.85) = 1441.15 (1429 - 71.45) = 1357.55 (1325 - 66.25) = 1258.75

Esto fue divertido.

Imprime todas las soluciones únicas con reflejo y rotación de wrt, en un agradable panal (por lo tanto, reducción del 5%)

Tiempo de ejecución: ~ 0.122s (122 milisegundos) en mi computadora portátil de 4 años.

Código Golfed (la edición se dio cuenta de que estaba repitiendo estúpidamente mis printfs, los reduje a una sola printf para obtener el máximo golf) ( nueva edición Llamadas reducidas para configurar funciones en funciones inteligentes más pequeñas, algunas otras microoptimizaciones):

import java.util.*;class A{boolean c(Set<Integer>u,int z){return!u.contains(z);}Set<Integer>b(Set<Integer>c,int...v){Set<Integer>q=new HashSet<Integer>(c);for(int x:v)q.add(x);return q;}void w(){Set<Integer>U,t,u,v,w,y,z;int a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,X,Z;X=20;Z=38;for(a=1;a<X;a++)for(b=1;b<X;b++)if(b!=a)for(c=1;c<X;c++)if(c!=a&&c!=b&&a+b+c==Z){U=b(new HashSet<Integer>(),a,b,c);for(d=1;d<X;d++)if(c(U,d))for(h=1;h<X;h++)if(h!=d&&c(U,h)&&a+d+h==Z){t=b(U,a,b,c,d,h);for(m=1;m<X;m++)if(c(t,m))for(q=1;q<X;q++)if(q!=m&&c(t,q)&&h+m+q==Z){u=b(t,m,q);for(r=1;r<X;r++)if(c(u,r))for(s=1;s<X;s++)if(s!=r&&c(u,s)&&q+r+s==Z){v=b(u,r,s);for(p=1;p<X;p++)if(c(v,p))for(l=1;l<X;l++)if(l!=p&&c(v,l)&&s+p+l==Z){w=b(v,p,l);for(g=1;g<X;g++)if(c(w,g)&&l+g+c==Z)for(e=1;e<X;e++)if(e!=g&&c(w,e))for(f=1;f<X;f++)if(f!=e&&f!=g&&c(w,f)&&d+e+f+g==Z){y=b(w,g,e,f);for(i=1;i<X;i++)if(c(y,i))for(n=1;n<X;n++)if(n!=i&&c(y,n)&&d+i+n+r==Z&&b+e+i+m==Z){z=b(y,i,n);for(o=1;o<X;o++)if(c(z,o))for(k=1;k<X;k++)if(k!=o&&c(z,k)&&m+n+o+p==Z&&r+o+k+g==Z&&b+f+k+p==Z)for(j=1;j<X;j++)if(c(z,j)&&j!=o&&j!=k&&a+e+j+o+s==Z&&c+f+j+n+q==Z&&h+i+j+k+l==Z){System.out.printf("%6d%4d%4d\n\n%4d%4d%4d%4d\n\n%2d%4d%4d%4d%4d\n\n%4d%4d%4d%4d\n\n%6d%4d%4d\n\n",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s);return;}}}}}}}}}public static void main(String[]a){(new A()).w();}}

La fuerza bruta es passe, pero el uso inteligente del hecho de que solo existe un conjunto muy pequeño de soluciones me llevó a una respuesta basada en la iteración, donde dentro de cada ciclo de la iteración solo considero enteros que aún no han sido "asignados". Hago uso de HashSet de Java para obtener búsquedas O (1) de números que se han utilizado anteriormente. Finalmente, hay exactamente 12 soluciones, pero cuando descontas tanto la rotación como la duplicación, esto se reduce a solo una solución única, por lo que cuando se encuentra la primera solución, la imprimo y termino. Echa un vistazo a mi código menos golfizado en github para obtener una visión más clara de cómo me estoy acercando a esta solución.

¡Disfrutar!

C, 366 bytes ( C ++ 541 450 )

#define R(i)for(int i=19;i;--i)
#define X(x)if(x>0&&!V[x]++)
#define K(X)X(a)X(b)X(c)X(d)X(e)X(f)X(g)X(h)X(i)X(j)X(k)X(l)X(m)X(n)X(o)X(p)X(q)X(r)X(s)
Q(x){printf("%d ",x);}
T=38,V[99];main(){R(h)R(c)R(s)R(a)R(l)R(q)R(e){int d=T-a-h,b=T-a-c,g=T-c-l,p=T-l-s,r=T-q-s,m=T-h-q,f=T-g-e-d,i=T-b-e-m,n=T-d-i-r,o=T-p-n-m,k=T-g-o-r,j=T-h-i-k-l;R(C)V[C]=0;K(X)K(+Q),exit(0);}}

Compilar con gcc -std=c99 -O3.

Imprime todas las soluciones únicas de módulo de rotación y reflejo, en el formato a b c d ..., una por línea.

Tiempo de ejecución: 0.8 segundos en mi computadora.

Enumeramos las celdas en el orden h -> c -> s -> a -> l -> q -> e para una máxima capacidad de eliminación. De hecho, la versión anterior solo intenta cada 20 ^ 7 asignaciones para esas variables. Entonces podemos calcular todas las otras celdas. Solo hay una solución única de módulo de rotación / reflejo. Se puede encontrar una versión C ++ más antigua, menos golfizada y ~ 20 veces más rápida (debido a la poda) en Github

Matlab: 333 320 caracteres

Este es un enfoque bastante tonto de fuerza bruta que no utiliza la recursividad. Construye soluciones parciales en z, que se imprime al final. Cada columna es una solución; los elementos se enumeran az de arriba a abajo. El tiempo de ejecución es de 1-2 horas.

z=[];
a='abc adh hmq qrs spl lgc defg beim mnop dinr rokg pkfb hijkl aejos cfjnq';while a[k,a]=strtok(a);n=length(k);x=nchoosek(1:19,n)';s=[];for t=x(:,sum(x)==38)s=[s,perms(t)'];end
m=0.*s;m(19,:)=0;m(k(1:n)-96,:)=s(1:n,:);y=[];for p=m for w=z m=[];l=w.*p~=0;if p(l)==w(l) y(:,end+1)=w+p.*(~l);end
end
end
z=[m,y];end
z

Corriendo desde Matlab:

>> aristotle;
>> z(:,1)

ans =

    9
   11
   18
   14
    6
    1
   17
   15
    8
    5
    7
    3
   13
    4
    2
   19
   10
   12
   16