Newsgroup: it.hobby.enigmi
Titolo: La scacchiera rotta

Non meno di 200 puzzles di questo tipo sono apparsi sul
mercato mondiale, in questi ultimi 100 anni.
Il primo esempio conosciuto agli esperti e' dovuto ad un
certo Henry Luers con un brevetto statunitense del 1880 dal
titolo di "Sectional Checkerboard", ma di cosa si tratta? 
Semplicemente di un certo numero di pezzi (polimini, diremmo
oggi) da mettere insieme per ottenere una classica
scacchiera 8x8, naturalmente la colorazione delle caselle va
rispettata.
Come dicevo sono noti ai collezionisti oltre 200 di questi
puzzles, venduti in diversi materiali, piu' comunemente in
cartoncino ed in legno per i piu' antichi e ovviamente in
plastica per i piu' recenti.
Il numero di soluzioni possibili varia e di molto, ad es.
uno di questi giochi venduti in Francia intorno al 1900 "Jeu
de l'echiquier, casse-tete diabolique" e' risolvibile in
87.726 modi diversi. 
Quello riportato qui sotto e' noto come "Checkerboard Cup-up
Puzzle" del 1962. La soluzione e' unica. Cimentatevi pure !
 ___    _        _     _        _
|x  |  | |_    _|x|   | |_     |x|_ 
  |x|  |x _|  |x  |   |x  |_   |_ x|_
  | |  | |      |x|     |x__|    |__x|
  |x|  |x|      |_| 
 _____      ___      ___        _
|x   x|   _|  x|    |_ x|      | |_
  |x|    |_ x|        | |_     |x  |
  |_|      |_|        |x__|    |_ X|  
                                 |_|
 _              _      _____
|x|___         | |    |x   x|
|  x__|     ___|x|      |x|
|x|        |  x__|      | |
|_|        |x|          |x|
:) dario

...
.
.
.
I pezzi
sono rovesciabili?
.
.
Ciao!  :o)
Livio
--------------------------------
Inviato via 
http://usenet.iol.it
 


.
.
Ho messo la mia soluzione qua:
.
http://www.geocities.com/liviozuc/images/dario8x8.gif
.
Il puzzle e'
stato risolto con il solver di Gerad Putter:
.
http://www.xs4all.nl/%7Egp/PolyominoSolver/Polyomino.html
.
e... qualche
trucchetto di mestiere.La domanda se i pezzi sono flippabili e' superflua:
la soluzione e' unica comunque!
.
A proposito, Dario ti chiedo una
cortesia. Nella mia ultima pagina:
.
http://www.geocities.com/liviozuc/polymultiforms3.html
.
presento anch'io
una scacchiera a pezzi: Two_Squares_One_Broken_(TSOB) dove i 32 pezzi sono
matematicamente definibili, cioe' non sono una divisione arbitraria della
scacchiera.
Il problema e' certamente risolvibile, ma non sto ricevendo
soluzioni, neppure dagli appassionati anglofoni. E' per caso nota tra le
200 che hai citato? Qualcuno un giorno scrisse: "Cosa faremmo senza la tua
memoria storica?"
.
Ciao  :o)


 sono rovesciabili?
One-side. Il cartoncino riporta la stampa solo da una parte.
:) ciao dario

 E' per caso nota tra le  200 che hai citato? 
No, no. 
Con l'aiuto dell'intera congrega internazionale dei
collezionisti Jerry Slocum pubblica il Compendium of
Chekerboard Puzzles.
L'ultimo aggiornamento e' del 1993, ma credo stia preparando
il nuovo numero.
Contiene solo pezzi da collezione che sono stati a suo tempo
messi in commercio (altrimenti se ne potrebbero inventare a
migliaia), e sono tutti formati da tessere con tagli
ortogonali lungo i bordi delle caselle.
Probabilmente non ricevi soluzioni del tuo puzzle, perche'
e' molto impegnativo.
ciao :) dario
PS, nel frattempo ho verificato anch'io che la sol. del
cut-up rimane unica anche capovolgendi i pezzi.


Grazie!
Ma quanti siete nel mondo, di collezionisti al tuo
livello, intendo?
In Italia tu solo, I suppose!
.
Ciao!!!


 livello, intendo?
Io sono un collezionista minore. Ci sono almeno 100 
raccolte piu' ricche della mia. Il motivo e' presto detto.
Io non li compro, quello che c'e', o sono puzzle scambiati o
realizzazioni di idee originali, le seconde servono per
ottenere le prime!
Esistono invece dei veri cultori, che non si lasciano
scappare nulla, si muovono ai quattro angoli del globo
appena sentono odore di novita'.
Sono tutti personaggi interessanti, piu' che collezionisti
sono dei veri ricercatori, cosi' nel corso degli anni,
appaiono opuscoli con studi capillari riguardanti i piu'
svariati argomenti, o ricerche su origine e storia di
particolari giochi.
Esistono 2 raccolte veramente imponenti, oltre che per la
quantita', superano entrambe i 30.000 pezzi, anche per la
rarita' e spesso l'unicita' di molti dei giochi che le
compongono. La prima e' del gia' citato Jerry Slocum, che
vive a Beverly Hills, ed e' stato il promotore, 25 anni fa,
dell'International Puzzle Party.  L'altra e' quella di James
Dalgety che ha assorbito per donazione, l'immensa collezione
di Edward Hordner, purtroppo deceduto per malattia l'anno
scorso, Piuttosto che disperdere il materiale, dal valore di
centinaia di milioni, Edward lo ha ceduto generosamente
all'amico James, (fra l'altro fondatore della Pentangle)
sapendo che lui onorera' la sua memoria, portando avanti il
museo nel migliore dei modi. La terza raccolta in ordine di
importanza, e' dell'instancabile Nob Yoshigaara di Tokio. Ho
detto instancabile, perche' e' presente ovunque si parli di
rompicapo o giochi matematici, ha scritto non meno di 40
libri e collabora con 5 o 6 riviste con rubriche ed
articoli, e' uno dei fondatori dell'ARM (l'accademia per le
ricreazioni matematiche) e molto altro ancora. Tutti questi
signori posseggono anche delle nutrite librerie. La piu'
incredibile e' quella di Will Shortz, l'editore della
rivista americana Games, ogni tanto pubblica un libro, che
e'.... l'elenco dei suoi libri di enigmistica e matematica
ricreativa. oltre 10.000 volumi!.
:) dario


.
Mi accorgo ora, provando un nuovo programma,
che, per i pezzi non rovesciabili, la soluzione e' unica anche ignorando la
colorazione delle caselle. Non me ne ero accorto perche' avevo imposto da
subito la condizione. I trucchetti di mestiere si riferivano a cio'. Avevo
triplicato i pezzi bucando le caselle nere ed inserendo dei perni sullo
shape. Ignorando la colorazione e rovesciando i pezzi, le soluzioni
possibili diventano 38, ma ritorna unica rispettando una colorazione
double-face. 


 Livio
Ma sul sito di Gerad Putter e' possibile scaricare il suo programma? Io lo
cerco ma non lo trovo.
Gas


.
Il programma di Gerard e'
un applet Java. Non lo trovi perche' si installa da se' sul tuo brouser.
Pazienta qualche giorno, sto preparando un SW friendly che ti permettera'
di utilizzarlo facilmente, se no effettivamente e' un po' ostico.  :o)))
.
Ciao  :o)
Livio
.



.
Vedi ora
il thread *Un SW per voi [polimini]*


 Puzzle" del 1962. La soluzione e' unica. Cimentatevi pure !
Uffa.  Più difficile di quello che prevedevo.
Ci ho messo troppo per fare un programmino, e poi il prog.
ci ha messo la bellezza di 12 minuti per trovare la soluzione.
La attacco sotto, anche se altri hanno già postato prima,
che l'hanno trovata.  La mia, almeno, è stata trovata da
un prog. scritto da me.  8-)
C'è nessuno che l'ha risolto a mano?
Ciao,
  Pierpaolo
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
iaafllll
iiaffflm
iiafgglm
niaggmmm
nnnngmhb
needhhhb
eeddhcbb
eddccccb


.
.
.
Bravo!
Benvenuto nel club di
quelli che si rompono le corna con questi puzzle.
.
Ci riassumeresti
brevemente il metodo che hai usato, linguaggio, PC, etc...


 brevemente il metodo che hai usato, linguaggio, PC, etc...
Volentieri. Il linguaggio usato è il Common Lisp, e sotto
ti appiccico il programma. Questo prog. trova la soluzione
in 12 minuti su un Athlon 700Mhz.
Tieni presente però che il prog. è molto rozzo. Ero già pronto
a rimboccarmi le maniche per applicare qualche potatura
più seria, ma non ce ne è stato bisogno. Ci ho messo parecchio
per scriverlo perché sono un po' arruginito, e perché ho usato
un compilatore che non conoscevo, su un trabiccolo adatto,
forse, per i videogiochi, ma non per programmare.
La tecnica: forza bruta.
I pezzi e le soluzioni parziali sono rappresentati come
somme di potenze di 2, in modo da poter controllare
intersezioni e unioni semplicemente con degli AND e OR
tra numeri interi. (nel sorgente, AND e OR sono LOGAND
e LOGIOR). Così, (0 0) è rappresentato da 1, (2 0) da 4,
(2 3) da 524.288 ecc.  Immagino che questa sia una tecnica
standard.
Il pezzo ((0 0) (1 0) (1 1)) è rappresentato da 1+2+512 = 515.
E a proposito: complimenti per le tue pagine. Ci sarebbe da
passarci qualche mese solo per dargli un'occhiata superficiale...
Ciao
  Pierpaolo
================
Ecco il prog.  Per l'occasione, aggiungo anche qualche
commento, anche se temo che il tutto ti risulterà arabo,
se non conosci il CL:
#|
 ___    _        _     _        _
|x  |  | |_    _|x|   | |_     |x|_
  |x|  |x _|  |x  |   |x  |_   |_ x|_
  | |  | |      |x|     |x__|    |__x|
  |x|  |x|      |_|
 _____      ___      ___        _
|x   x|   _|  x|    |_ x|      | |_
  |x|    |_ x|        | |_     |x  |
  |_|      |_|        |x__|    |_ X|
                                 |_|
 _              _      _____
|x|___         | |    |x   x|
|  x__|     ___|x|      |x|
|x|        |  x__|      | |
|_|        |x|          |x|
|#
(declaim (optimize speed (safety 0) (debug 0)))
;;(declaim (optimize (safety 3) (debug 3)))
;;; La descrizione dei pezzi.
;;; La lettera indica il colore del primo quadretto
;;; I pezzi sono nell'ordine della figura sopra.
(defparameter *pezzi*
  '((n (1 0) (1 1) (1 2) (1 3) (0 3))
    (n (0 0) (0 1) (0 2) (0 3) (1 2))
    (b (1 0) (1 1) (1 2) (1 3) (0 2))
    (b (0 2) (0 1) (1 1) (1 0) (2 0))
    (n (0 2) (0 1) (1 1) (1 0) (2 0))
    (n (0 2) (1 2) (2 2) (1 1) (1 0))
    (b (0 1) (1 0) (1 1) (1 2) (2 2))
    (b (0 2) (1 2) (1 1) (1 0) (2 0))
    (b (0 3) (0 2) (0 1) (1 2) (1 1) (1 0))
    (n (0 3) (0 2) (0 1) (0 0) (1 2) (2 2))
    (n (0 0) (0 1) (1 1) (2 1) (2 2) (2 3))
    (n (0 3) (1 3) (2 3) (1 2) (1 1) (1 0))))
;;; bounding-box ((1 0) (1 1) (1 2) (1 3) (0 3))  --> ((0 0) (1 3))
;;; Ora che la riguardo, questa si poteva fare in 2 righe.  !@!#^!!
(defun bounding-box (forma)
  (let ((minx 9999)
        (maxx -9999)
        (miny 9999)
        (maxy -9999))
    (loop for (x y) in forma
          do
          (when (< x minx)
            (setq minx x))
          (when (> x maxx)
            (setq maxx x))
          (when (< y miny)
            (setq miny y))
          (when (> y maxy)
            (setq maxy y)))
    (list (list minx miny)
          (list maxx maxy))))
(defun ruota-90 (forma)
  (mapcar (lambda (p)
     (let ((x (first p))
                  (y (second p)))
              (list y (- x))))
          forma))
(defun tutte-le-rotazioni (forma)
  (let ((acc '()))
    (push forma acc)
    (setq forma (ruota-90 forma))
    (push forma acc)
    (setq forma (ruota-90 forma))
    (push forma acc)
    (setq forma (ruota-90 forma))
    (push forma acc)
    (mapcar #'primo-quadrante (nreverse acc))))
;;; Normalizza FORMA
;;; la trasla nel primo quadrante, appoggiata agli assi.
(defun primo-quadrante (forma)
  (let ((p0 (first (bounding-box forma))))
    (mapcar (lambda (p)
              (list (- (first p) (first p0))
                    (- (second p) (second p0))))
            forma)))
(defun trasla (forma x y)
  (mapcar (lambda (p)
            (list (+ (first p) x)
                  (+ (second p) y)))
          forma))
;;; Tutte le posizioni possibili di PEZZO
;;; in una scacchiera di lato LATO.
;;; Tiene conto del vincolo del colore.
(defun tutte-le-posizioni (pezzo lato)
  (let* ((bb (bounding-box (cdr pezzo)))
         (p1 (first bb))
         (p2 (second bb))
         (largx (- (first p2) (first p1)))
         (largy (- (second p2) (second p1)))
         (parip (eq (first pezzo) 'b))
         (punto-colorato (first (rest pezzo))))
    (let ((acc '()))
      (loop for x from 0 below (- lato largx)
            do (loop for y from 0 below (- lato largy)
                     do (when (eq parip (evenp (+ x y (first punto-colorato)
                                                  (second punto-colorato))))
                          (push (trasla (cdr pezzo) x y) acc))))
      acc)))
;;; Tutte le posizioni possibili di tutti i PEZZI
(defun tutte-tutte-le-pos (pezzi lato)
  (mapcar (lambda (l)
            (sort l #'<))
          (mapcar
           (lambda (p)
             (mapcan (lambda (p)
                       (mapcar (lambda (f)
                                 (forma->numero f lato))
                               (tutte-le-posizioni p lato)))
                     (mapcar (lambda (r)
                               (cons (car p) r))
                             (tutte-le-rotazioni (cdr p)))))
           pezzi)))
;;; Trasf.  ((0 0) (0 1) (1 1))  -->  515
(defun forma->numero (forma lato)
  (let ((acc 0))
    (mapc (lambda (p)
            (setf acc (logior acc (punto->numero p lato))))
          forma)
    acc))
;;; Trasf. (2 3)  --> 524288
(defun punto->numero (p lato)
  (expt 2 (+ (* lato (first p))
             (second p))))
;;; Costante. Per gli ultimi 2 pezzi si fa prima a provare
;;; esaustivamente che a cercare di potare (costante stimata
;;; a naso, probabilmente completamente sballata).
(defparameter *taglio-non-potorio* 2)
;;; La funzione principale.
(defun risolvi ())
  (let* ((lato 8)
         (pezzi *pezzi*)
         (taglio (- (length pezzi) *taglio-non-potorio*))
         (scac-piena (1- (expt 2 (* lato lato)))))
    (labels ((fanpezzo (scac pezzi sol livello)
                   (cond ((and (< livello taglio)
                           (posizione-non-buona scac pezzi scac-piena))
                      nil)
                     ((null pezzi)
                      (write (reverse sol))
                      (terpri)
                      (disegna-soluzione (reverse sol) lato)
                      (return-from risolvi 'eureka))
                     ((null (car pezzi)) nil)
                     (t (cond ((zerop (logand (caar pezzi) scac))
                               (or (fanpezzo (logior (caar pezzi) scac)
                                             (cdr pezzi)
                                             (cons (caar pezzi) sol)
                                             (1+ livello))
                                   (fanpezzo scac
                                             (cons (cdar pezzi) (cdr pezzi))
                                             sol
                                             livello)))
                              (t (fanpezzo scac
                                           (cons (cdar pezzi) (cdr pezzi))
                                           sol
                                           livello)))))))
      (fanpezzo 0 (tutte-tutte-le-pos pezzi lato) '() 0))))
;;; Questo è l'unico potatore usato.
;;; Scarta la sol. parziale SCAC se ci sono dei quadretti che
;;; non possono essere coperti da nessuno dei PEZZI rimasti.
(defun posizione-non-buona (scac pezzi piena)
  (let ((copertura scac))
    (loop for pezzo in pezzi do
          (loop for forma in pezzo
                when (zerop (logand forma scac))
                do (setq copertura (logior copertura forma))
                ))
    (/= copertura piena)))
;;; Da qua in giù, ci sono cose che servono solo
;;; per disegnare la soluzione.
;;; Trasf.  515  -->  ((0 0) (0 1) (1 1))
(defun numero->forma (n lato)
  (nreverse
   (mapcar (lambda (n)
             (multiple-value-list (floor (1- n) lato)))
           (let ((acc '()))
             (loop for p2 from 1
                   until (zerop n)
                   do
                   (when (oddp n)
                     (push p2 acc))
                   (setq n (floor n 2)))
             acc))))
(defconstant lettere (coerce "abcdefghilmnopqrstuvz" 'list))
(defun disegna-soluzione (sol &optional (lato 8))
  (let ((scac (make-array (list lato lato) :initial-element #\.)))
    (loop for forma in sol
          for lettera in lettere
          do
          (loop for p in (numero->forma forma lato)
                do (setf (aref scac (first p) (second p)) lettera)))
    (fresh-line)
    (dotimes (x lato)
      (dotimes (y lato)
        (princ (aref scac x y)))
      (terpri))
    (terpri)))
;;; Fine

 Poiche' i solver non *vedono* eventuali colorazioni dei pezzi...
Fra le molte opzioni del BCBox (quello che uso) c'e' la
possibilita' di lavorare con  pezzi colorati a scacchiera.
Questo mi ha fatto pensare ad un'altro modo di affrontare i
polilati, senza dover raddoppiarne le dimensioni.
Basta considerare i singoli sticks come diagonali di
polimini scacchierati (si puo' dire ?) 
Diagonali orizzontali per le caselle nere e verticali per le
bianche ! o viceversa.
Questo mi allarga, e di molto, il campo di lavoro.
Livio, cosa e' rimasto ancora da risolvere dei polilati ??
Forse con questo metodo potrei farcela.
:) dario


.
.
Gli eptavermi!   Hi hi hi :)) :))
:)) :)) :)) 
.
Eppure son convinto che si puo'.
Ho la forte speranza che
il rapporto Num.combinaz./Num.Sol. sia un numero ragionevole, tale da far
trovare almeno una sol.
Occorre fare una buona parte a mano, cercando di
lasciare al solver gli ultimi 20..22 pezzi *facili*.
.
In boca al lupo!
Livio


 Io lo cerco ma non lo trovo.
...Ecco il link:
http://www.xs4all.nl/~gp/PolyominoSolver/downloadsolver.htm
CiaO,
Massimo
PS...Il prg di Livio e' utilissimo.
     ;-))
-- 
Posted from 
net128-053.mclink.it
 [195.110.128.53] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG


Grazie, troppo
buono. Daresti un'occhiata qui, per favore (senza impegno, s'intende!):
.
http://www.geocities.com/liviozuc/sexomini.html
.
Mi interessa scoprire
il numero delle soluzioni del rettangolo 6x4 coperto da sexomini one-side.
Io ci sto provando con altre strade (forse anche Dario Uri). Il tuo metodo
mi sembra molto adatto. Poiche' i sexomini sono *baricentrati*, bisogna
solo spostarli nelle 24 posizioni. Ogni lato puo' assumere 1 su 3 valori,
quindi ciascun sexomino puo' essere rappresentato in ogni sua rotazione da
un numero  0..80 (sta nel byte!). Soltanto 7 pezzi possono occupare gli
angoli e scegliendoli opportunamente si possono evitare controlli di
riflessioni e simmetrie sulle soluzioni finali. 
6 pezzi, quelli full-
sexed, possono occupare solo le posizioni centrali. Con queste limitazioni
si possono tagliare un sacco di rami secchi e la soluzione diventa (IMHO)
alla portata di tempi onesti.


 alla portata di tempi onesti.
E poi, anche se i tempi non sono onesti, che ci importa?  Tanto lavora la
macchina.    8-)
Ciao
  Pierpaolo

 il numero delle soluzioni del rettangolo 6x4 coperto da sexomini one-side.
Ma tu conosci solo la soluzione pubblicata nel tuo sito, o
ne conosci altre?
Come primo passo, io ne ho trovata una, che č diversa
dalla tua.  Tempo di calcolo: circa un'ora.  Non ho ancora
calcolato che frazione dello spazio delle soluzioni il prog
ha dovuto esplorare per trovarla, quindi non ho ancora una
stima, nemmeno inaffidabilissima, del numero di soluzioni
totale, e del tempo che sarebbe richiesto, con il programma
cosě com'č.
Ecco la soluzione:
 N  N  N  N  N  N
N@FM@MF@MF@MF@MF@N
 M  F  F  M  N  F
 F  M  M  F  N  M
N@FM@FM@MF@FM@MF@N
 F  F  M  M  N  F
 M  M  F  F  N  M
N@FM@MF@FM@MF@FM@N
 N  F  F  F  N  M
 N  M  M  M  N  F
N@NN@MF@MF@FM@NN@N
 N  N  N  N  N  N
E sotto appiccico il programma, hai visto mai interessi
a qualcuno.    8-)
Ciao,
  Pierpaolo
================
;;(declaim (optimize (safety 3) (debug 3)))
(declaim (optimize speed (safety 2) (debug 0)))
(defparameter *sexomini*
  '((n n n n) (n f n n) (n m n n) (f f n n) (f m n n) (m f n n) (m m n n) (n
f n f)
    (n m n f) (n m n m) (f f n f) (f m n f) (m f n f) (m m n f) (f f n m) (f
m n m)
    (m f n m) (m m n m) (f f f f) (f m f f) (m m f f) (f m f m) (m m f m) (m
m m m)))
(defparameter *sexoconv*
  '((n . 0) (m . 1) (f . -1)))
(defun lettere->numeri (quadrupla)
  (mapcar (lambda (lettera)
            (cdr (assoc lettera *sexoconv*)))
          quadrupla))
(defun numeri->lettere (quadrupla)
  (mapcar #'numero->lettera quadrupla))
(defun numero->lettera (n)
  (car (rassoc n *sexoconv*)))
(defstruct (sexomino (:constructor make-sexomino (n e s o)))
  (n 0 :type (integer -1 1))
  (e 0 :type (integer -1 1))
  (s 0 :type (integer -1 1))
  (o 0 :type (integer -1 1)))
(defun i-sexomini ()
  (mapcar (lambda (q)
            (tutte-le-orientazioni (apply #'make-sexomino (lettere->numeri
q))))
          *sexomini*))
(defun ruota-90 (sexomino)
  (make-sexomino (sexomino-o sexomino)
                 (sexomino-n sexomino)
                 (sexomino-e sexomino)
                 (sexomino-s sexomino)))
(defun tutte-le-orientazioni (sexomino)
  (let ((acc '()))
    (push sexomino acc)
    (push (setq sexomino (ruota-90 sexomino)) acc)
    (push (setq sexomino (ruota-90 sexomino)) acc)
    (push (setq sexomino (ruota-90 sexomino)) acc)
    (remove-duplicates acc :test #'equalp)))
(defun crea-tabella ()
  (let ((tabella (make-array '(8 6) :initial-element nil))
        (neutro (make-sexomino 0 0 0 0)))
    (loop for i from 0 below 8 do
          (setf (aref tabella i 0) neutro
                (aref tabella i 5) neutro))
    (loop for i from 0 below 6 do
          (setf (aref tabella 0 i) neutro
                (aref tabella 7 i) neutro))
    tabella))
(defun posizioni-da-riempire ()
  (let ((angoli '((1 1) (1 4) (6 4) (6 1)))
        (lato-1y '((1 2) (1 3)))
        (lato-x4 '((2 4) (3 4) (4 4) (5 4)))
        (lato-6y '((6 2) (6 3)))
        (lato-x1 '((5 1) (4 1) (3 1) (2 1)))
        (centrali (loop for x from 2 to 5
                        nconc (loop for y from 2 to 3
                                    collect (list x y)))))
    (mapcar (lambda (l) (apply #'cons l))
            (append angoli lato-1y lato-x4 lato-6y lato-x1 centrali))))
(defparameter *amp-cella-disegno* 3)
(defun scrivi-tabella (tabella)
  (let* ((immx (* 6 *amp-cella-disegno*))
         (immy (* 4 *amp-cella-disegno*))
         (immagine (make-array (list immx immy) :initial-element #\Space)))
    (loop for y from 1 to 4
          for yim from 1 by 3
          do (loop for x from 1 to 6
                   for xim from 1 by 3
                   for elemento = (aref tabella x y)
                   when elemento do
                   (setf (aref immagine xim yim) #\@)
                   (setf (aref immagine (+ xim 0) (+ yim 1))
                         (numero->lettera (sexomino-n elemento)))
                   (setf (aref immagine (+ xim 1) (+ yim 0))
                         (numero->lettera (sexomino-e elemento)))
                   (setf (aref immagine (+ xim 0) (- yim 1))
                         (numero->lettera (sexomino-s elemento)))
                   (setf (aref immagine (- xim 1) (+ yim 0))
                         (numero->lettera (sexomino-o elemento)))))
    (fresh-line)
    (loop for y from (1- immy) downto 0 do
          (loop for x from 0 below immx
                do (princ (aref immagine x y)))
          (terpri))))
(defvar *logfile* "c:/users/pierpa/sexomini-soluzioni")
(defun eureka (tabella)
  (scrivi-tabella tabella)
  (with-open-file (*standard-output* *logfile*
                                     :direction :output
                                     :if-exists :append)
    (with-standard-io-syntax
      (princ "================")
      (terpri)
      (write tabella)
      (terpri)
      (print (get-universal-time))
      (scrivi-tabella tabella))
    (throw 'fittiziamente 'fittizio)))
(defun compatibile (sexomino posizione tabella)
  (let ((x (car posizione))
        (y (cdr posizione)))
    (and (not (aref tabella x y))
         (or (not (aref tabella x (1+ y)))
             (zerop (+ (sexomino-n sexomino)
                       (sexomino-s (aref tabella x (1+ y))))))
         (or (not (aref tabella (1+ x) y))
             (zerop (+ (sexomino-e sexomino)
                       (sexomino-o (aref tabella (1+ x) y)))))
         (or (not (aref tabella x (1- y)))
             (zerop (+ (sexomino-s sexomino)
                       (sexomino-n (aref tabella x (1- y))))))
         (or (not (aref tabella (1- x) y))
             (zerop (+ (sexomino-o sexomino)
                       (sexomino-e (aref tabella (1- x) y)))))
         )))
(defvar *ogni-quanto-aggiorna* 100000000)
(defvar *scrive-zac* nil)
(defun risolvi-2 (sexomini)
  (let ((tempo (run-time))
        (cont *ogni-quanto-aggiorna*)
        (tabella (crea-tabella))
        (quanti-zac 0))
    (labels
      ((fansexomino (sexomini)
         (when (zerop (decf cont))
           (setq cont *ogni-quanto-aggiorna*)
           (scrivi-tabella tabella)
           (let ((adesso (run-time)))
             (format t "= c: ~,,'.:D == t: ~,1F == p: ~D =~%"
                     cont (- adesso tempo) (- 24 (length sexomini)))
             (setq tempo adesso))
           ;;(sleep 1)
           )
         (cond ((null sexomini)
                (print "EUREKA!")
                (eureka tabella)
                nil)
               ((not (posizione-accettabile tabella sexomini))
                (incf quanti-zac)
                (when (and *scrive-zac*
      (>= (length sexomini) *scrive-zac*))
                  (format t "~A ZAC! (lung. ~A)~%" quanti-zac
                          (- 24 (length sexomini))))
                nil)
               (t (let ((sexomino (first sexomini)))
                    (loop for orientazione in sexomino do
                          ;;(format t "orientazione: ~S~%" orientazione)
                          (let ((forma (first orientazione)))
                            (loop for posizione in (rest orientazione)
                                  when (compatibile forma posizione tabella)
                                  do
                                  (setf (aref tabella (car posizione) (cdr
posizione))
                                        forma)
                                  (fansexomino (cdr sexomini))
                                  (setf (aref tabella (car posizione) (cdr
posizione))
                                        nil)))))))))
    (fansexomino sexomini))))
(defvar *le-posizioni* (posizioni-da-riempire))
(defun posizione-accettabile (tabella pezzi)
  (loop for posizione in *le-posizioni*
        always (or (aref tabella (car posizione) (cdr posizione))
                   (copribile posizione pezzi tabella))))
(defun copribile (posizione pezzi tabella)
  (loop for pezzo in pezzi
        thereis (copribile-orientazione posizione pezzo tabella)))
(defun copribile-orientazione (posizione pezzo tabella)
  (loop for (orientazione . posizioni) in pezzo
        thereis (compatibile orientazione posizione tabella)))
(defun ris ()
  (let ((posizioni (posizioni-da-riempire))
        (sexomini (i-sexomini))
        (tabella (crea-tabella)))
    (risolvi-2
     (mapcar (lambda (orientazioni)
               (mapcar (lambda (orientazione)
                         (cons orientazione
                               (remove-if-not (lambda (pos)
                                                (compatibile orientazione
                                                             pos tabella))
                                              posizioni)))
                       orientazioni))
             sexomini))))
;;; Fine

ne conosci altre?
.
.
Complimenti cmq per la soluzione
autarchica!
Per precedenti soluzioni su questo NG, soprattutto ad opera di
Dario Uri, ti consiglio di cercare con 
google.com
 i threads [MA]Sexomini e
[MA]Sexomini(2).
Sono cmq convinto (IMHO) che si possa trovare la
soluzione del problema 'quante soluzioni ha il rettangolo 6x4' con un
programma dedicato come il tuo, tagliando molti rami secchi per
massimizzarne l'efficienza.


 massimizzarne l'efficienza.
Ci ho riguardato. Il piu' veloce tra i  programmi a mia
disposizione ce la potrebbe fare in una decina di giorni, il
problema sta nel fatto che non solo le conta , ma le vuole
salvare su file. L'albero diventa enorme e la ram si satura
presto, in piu' il file delle sol. crescerebbe in modo
preoccupante.
Secondo me sarebbe meglio, come gia' detto, dividere il
problema in parti, oltre ad essere meno rischioso in caso di
imprevisti, lo si potrebbe affrontare in gruppo.
Le 7 tessere idonee ad occupare un angolo, salvo errori,
danno luogo a 510 casi possibili.
Mediamente occorre una mezzora per caso.
Ci vogliamo provare ??  
:) dario

Ci vogliamo provare ??
.
.
Anche il mio metodo si
incasina dopo la 
100.000.ma
 sol. e non so perche'.
.
Ti giuro che ci ho
provato a completare la tua tabella di 510 righe, ma dopo una cinquantina
non ero piu' sicuro di nulla. Che ne diresti di provare a ridurle a 34
righe (credo) bloccando due angoli solamente? Una notte per riga dovrebbe
bastare. Occorre pero' che almeno due *ricercatori* confermino i risultati
parziali. Io non mi fido dei miei  :o)
.
Ciao!


 parziali. Io non mi fido dei miei  :o)
Va bene, potrei lavorare con 2 PC.
Hai voglia di preparare il prospetto ?
In questo momento sono un po' preso.
ciao :) dario




.
.
.
.
Ohi, ohi, ohi!
Ho paura che due
pezzi non bastino per escludere R&R tra i sottoinsiemi.
Tutto da rifare.
Ripenso le tue 510 ...
.
Ciao  :o(


 Ripenso le tue 510 ...
Un aggiornamento sul mio programma.
Fino a poco fa lo avevo fatto girare qualche volta per
cercare di capire dove intervenire per ottimizzarlo, ma
sempre facendolo fermare alla prima soluzione trovata.
E facevo molto male.
Ora  l'ho fatto continuare e sta sputando fuori soluzioni a
una velocità incredibile.  Per esempio, dopo la prima ora
circa che ci mette per trovare la prima soluzione, nei
successivi 61 secondi ne trova altre 67.   8-)
E ancora non ci ho messo la potatura dei trisex (che Livio
mi ha suggerito in email).
Anche i programmi che mi scrivo da me non finiranno mai
di sorprendermi: quando ho iniziato a scrivere questo
messaggio, il file delle soluzioni era grande 75.636 bytes,
ora è 2.220.948 bytes. E scrivo abbastanza velocemente... 8-)
Stasera, ci aggiungo la potatura dei trisex e un po' di
bookkeping per generare meno output per soluzione.
Poi vi faccio sapere.
Ciao,
  Pierpaolo

 Un aggiornamento sul mio programma.
Un altro aggiornamento:  6574 soluzioni in 9804 secondi.
Pierpaolo




.
.
.
Cmq bravo! Comincio a scommettere che ce la farai. Il problema
sara': come faremo a controllare l'esattezza della soluzione?
Ho
pubblicato questa pagina:
.
http://www.geocities.com/liviozuc/sexomininum2.html
.
C'e' un cenno al
tuo tentativo e c'e' la tabella di 510 righe proposta da Dario Uri. 
Se
qualcuno vuole aiutarci a completare o verificare la tabella, sara' accolto
a braccia aperte  :o)
.
Ciao!


 tuo tentativo e c'e' la tabella di 510 righe proposta da Dario Uri.
Bhe' visto che una parte del lavoro l'hai gia' fatta, tanto
vale continuare.
Il tempo di elaborazione e' inferiore al previsto, e' speso
quasi tutto nella preparazione dei dati:
Num      sol   minuti
105      56     4.39
106     136     5.45
107     328     4.46
108     558     7.16
111     710     1.34
112     174     2.59
Stasera mi organizzo meglio.
:) ciao dario

Eccone altre:
Num.  Sol.
113   868
114    58
115  1112
116   410
117     0
118   464
119     0
120   416
ciao :) dario

 sara': come faremo a controllare l'esattezza della soluzione?
Se lo risolviamo sia io che tu e Dario Uri, dovremmo confermarci
il risultato a vicenda.
Ho aggiunto al programma la potatura dei trisex e ora va
un po' più veloce: in questo momento ha trovato 9.696
soluzioni in 5.542 secondi: 1,74 soluzioni al secondo.
A questo punto smetto di spippolarci e lo lascio girare
in pace.
Ciao
  Pierpaolo

 in pace.
Aggiornamento delle 11.20:
71.992 soluzioni in 34.205 secondi.
2,1 soluzioni al secondo.
Ogni soluzione ha una duale riflessa, quindi in
pratica ha trovato 143.984 soluzioni.
Lo spazio esaminato è meno di un sesto del totale
(non ho fatto una stima più precisa), quindi, se lo
spazio rimanente ha una densità di soluzioni
paragonabile, siamo a una stima di più di
850.000 soluzioni.
(    8-O
Ciao
  Pierpaolo

120   416
.
.
.
.
Tanto perche'
tu non ti senta solo....
.
500__3,6,24,19__2310
501__3,19,6,24__288
502__3,19,24,6__2372
503__3,24,6,19__248
504__3,24,19,6__886
.
Chissa'
con un metodo come quello di Pierpaolo (romeo bernardi) che non sia
possibile farlo automaticamente, almeno un pezzo, tabulando direttamente i
risultati, tanto cosi' per fare una verifica incrociata.
.
Qualcuno sa
perche' le soluzioni sono tutte pari?


 perche' le soluzioni sono tutte pari?
Bho!?
Nel frattempo ho finito la serie con gli angoli 1,2,4,19:
num.  sol.
127   566
128   258
129     0
130   410
131     0
132   414
133   184
134   460
135   256
136   310
137   184
138   506
139   378
140   744
141     0
142   936
143     0
144  1288
:) dario


Di solito si considerano le soluzioni
al netto delle riflessioni e delle rotazioni. Le sol. di Dario e le mie
sono intese cosi'. Diversamente ogni soluzione rettangolare ha tre gemelli:
una riflessione, una rotazione, la riflessione della rotazione. A rigore ci
sarebbe da discutere, poiche' i pezzi sono la serie completa ed esaustiva
di tutte le combinazioni non-rovesciabili, quindi ogni pezzo non-simmetrico
ha il suo simmetrico. La soluzione riflessa, in realta', e' un'altra
soluzione perche' i pezzi riflessi non sono piu' gli stessi. Al di la'
dello specchio alcuni pezzi *cambiano nome*, direbbe Lewis Carroll.  Mi
viene in mente Alice che guarda il gattino nello specchio bere il latte
nello specchio e si chiede: *Non gli fara' male?* 
.
Sapete perche'?
.
Ciao  :o)


 Sapete perche'?
Se ti riferisci a cose a livello molecolare, credo di sì.
(Ne ha parlato, mi sembra, Martin Gardner?)
Ciao,
  Pierpaolo

Ecco una decade fresca fresca:
.
Nr.___Angoli________Sol.
.
490__(3,6,24,4)____826
 491__(3,24,4,6)____290
 492__(3,24,6,4)____216
493__(3,4,19,24)___216
 494__(3,4,24,19)___290
 495__(3,19,4,24)___826
496__(3,19,24,4)___208
 497__(3,24,4,19)___336
 498__(3,24,19,4)___164
499__(3,6,19,24)___330
.
Devo dire che con il Pentium 800 dell'ufficio,
il solver di Gerard
e qualche trucchetto, raggiungo circa la velocita' di
Dario.
Queste pero' sono fatte a casa con un catorcetto di Pentium 100...
Facendo altro, di tanto in tanto si lancia una nuova configurazione.
.
Nessun altro vuole provare l'ebbrezza di trovare soluzioni? Sappiate che
puo' essere entusiasmante.
.
Ciao  :o)
Livio
.
http://www.geocities.com/liviozuc/sexomininum2.html
.
('stanotte
l'aggiorno  :)


 > in pace.
Dixit.  In realtà ho continuato a spippolarci. La versione
corrente, che sta girando da ieri sera è molto più veloce.
Allora, la situazione corrente è:
147.928 soluzioni trovate in 40.771 secondi,
quindi 3,62 sol/sec.
Un risultato parziale, che forse può essere utile per la
vostra tabella (se ancora non avete finito questo caso),
o per controllo (se invece lo avete finito): ci sono
71.992 soluzioni (da moltiplicare x 2) che hanno il
pezzo neutro in un angolo.
Ciao,
  Pierpaolo

 quindi 3,62 sol/sec.
Qualcosa ho trovato.  E cioè un bug nel mio programma.
Mi dice che le 147.928 soluzioni di cui sopra sono tutte,
il che non può essere vero, dato che manca la soluzione
campione pubblicata sulla pagina del problema.
Sigh.  Cercherò di aggiustarlo, ma ora non ho più molto
tempo libero, quindi, se mai lo aggiusto, andrà per le
lunghe.
Posso mandare programma e 147.928 soluzioni a chi me
li chiede.
Ciao,
  Pierpaolo

Angoli 1,2,6,19.
Num.   Sol.
169      0
170      0
171      0
172      0
173      0
174      0
175    324
176    390
177    232
178    176
179    236
180    268
181    390
182    324
183    236
184    176
185    232
186    268
187    498
188    498
189      0
190    748
191      0
192    700
:) dario

 campione pubblicata sulla pagina del problema.
Sigh. Il bug era in realtà nelle mie aspettazioni. Mi ero
dimenticato che a causa dell'ultima ottimizzazione
applicata le soluzioni venivano trovate in un ordine
differente da quello di prima.
Insomma, la soluzione campione c'è. Quindi, a meno di _altri_
bug, il numero di soluzioni, senza riflessioni è di 147.928, quindi
295.586 soluzioni totali.
Sono bastate circa 12 ore di calcolo.
Classificandole in base alla posizione del pezzo neutro si
possono ripartire come segue:
71.992 hanno il pezzo neutro in (1,1) (la prima coordinata è il lato lungo);
8.688 in (1,2)
5.928 in (3,1)     (tra queste, la soluzione campione)
61.320 in (2,1)
Ciao,
  Pierpaolo


.
Sapevo che ce l'avresti fatta!  :o)))
Ora ci vuole
qualche conferma galileiana. Domani spero di avere per le mani un super
pentium, provero' a confermare almeno un dato parziale con un solver. Tu
potresti fare un pezzetto di tabella con lo stesso programma? Sarebbe una
conferma ulteriore.
.
La paginetta e' aggiornata anche con i dati di
Dario:
.
http://www.geocities.com/liviozuc/sexomininum2.html
.
Ciao
:o)


 conferma ulteriore.
Non ho bisogno di rifare il calcolo. Le soluzioni se ne stanno lì
tutte e 147.928 in un file di poco meno di 23 mega.
Tu dammi una condizione qualsiasi, e ci metto un attimo a fare
una passata selezionando quelle che soddisfano la condizione.
Possibilmente, dammi da contare qualcuno dei casi non pubblicati,
così la verifica la faccio al buio.
Oppure, ora mi guardo la tabella, mi scelgo qualche casella vuota,
e poi ti posto qua sotto il risultato.
BTW, ecco la 83.868esima soluzione:
(83868
 (nfmn nmmm nmnf nmmf nfmf nnmm
  ffmn ffmm nmnm ffff fmfm fnff
  fmmn fmff nfnf mmmm mmmf mnmf
  fnnn mnnn nnnn ffnn ffnm fnnm)
 24994.67)
Questa, riflessa lungo un asse orizzontale dà la soluzione
campione. 24994.67 sono i secondi passati dall'inizio del
programma.
Ciao,
  Pierpaolo

 conferma ulteriore.
Un pezzetto, no, non c'è gusto.  Eccola tutta: le righe che mancano sono
da intendersi 0; se qualcosa non torna, è più probabile che abbia sbagliato
nel compilare la tabella piuttosto che a trovare le soluzioni, visto il
procedimento un po' incasinato seguito per ottenerla:
1o  4   3   6  : 288
1o  4   3   19 : 1032
1o  4   2v  6  : 710
1o  4   2v  19 : 256
1o  4   2v  24 : 182
1o  6   3   4  : 1032
1o  6   3   19 : 1008
1o  6   2v  4  : 868
1o  6   2v  19 : 236
1o  6   2v  24 : 56
1o  19  3   4  : 288
1o  19  3   6  : 1008
1o  19  2v  4  : 184
1o  19  2v  6  : 232
1o  24  2v  4  : 86
1o  24  2v  6  : 328
2o  4   1v  19 : 328
2o  4   1v  24 : 86
2o  6   1v  19 : 232
2o  6   1v  24 : 184
2o  6   3   19 : 1008
2o  6   3   24 : 288
2o  19  1v  4  : 56
2o  19  1v  6  : 236
2o  19  1v  24 : 868
2o  19  3   6  : 1008
2o  19  3   24 : 1032
2o  24  1v  4  : 182
2o  24  1v  6  : 256
2o  24  1v  19 : 710
2o  24  3   6  : 1032
2o  24  3   19 : 288
4   1v  3   6  : 460
4   1v  3   19 : 876
4   1v  3   24 : 610
4   1v  2v  6  : 494
4   1v  2v  19 : 272
4   1v  2v  24 : 370
4   1o  3   6  : 252
4   1o  3   19 : 850
4   1o  3   24 : 218
4   1o  2v  6  : 310
4   1o  2v  19 : 174
4   1o  2v  24 : 200
4   2v  1v  6  : 650
4   2v  1v  19 : 172
4   2v  1v  24 : 370
4   2v  3   6  : 708
4   2v  3   19 : 262
4   2v  3   24 : 470
4   2o  1v  6  : 414
4   2o  1v  19 : 558
4   2o  1v  24 : 270
4   2o  3   6  : 264
4   2o  3   19 : 802
4   2o  3   24 : 220
4   6   1v  2v : 280
4   6   1v  2o : 566
4   6   1v  19 : 1410
4   6   1v  24 : 790
4   6   1o  19 : 1008
4   6   3   1v : 608
4   6   3   1o : 614
4   6   3   2v : 192
4   6   3   2o : 600
4   6   3   19 : 2372
4   6   3   24 : 336
4   6   2v  1v : 328
4   6   2v  1o : 540
4   6   2v  19 : 532
4   6   2v  24 : 314
4   6   2o  19 : 504
4   6   2o  24 : 144
4   19  1v  2v : 582
4   19  1v  2o : 360
4   19  1v  6  : 904
4   19  1v  24 : 288
4   19  1o  6  : 1008
4   19  3   1v : 688
4   19  3   1o : 122
4   19  3   2v : 940
4   19  3   2o : 110
4   19  3   6  : 2310
4   19  3   24 : 806
4   19  2v  1v : 300
4   19  2v  1o : 460
4   19  2v  6  : 416
4   19  2v  24 : 330
4   19  2o  6  : 504
4   24  1v  2v : 308
4   24  1v  2o : 312
4   24  1v  6  : 1346
4   24  1v  19 : 146
4   24  3   1v : 348
4   24  3   1o : 446
4   24  3   2v : 616
4   24  3   2o : 426
4   24  3   6  : 826
4   24  3   19 : 352
4   24  2v  1v : 158
4   24  2v  1o : 230
4   24  2v  6  : 552
4   24  2v  19 : 240
4   24  2o  6  : 516
6   1v  3   4  : 568
6   1v  3   19 : 482
6   1v  3   24 : 278
6   1v  2v  4  : 638
6   1v  2v  19 : 350
6   1v  2v  24 : 192
6   1o  3   4  : 252
6   1o  3   19 : 218
6   1o  2v  4  : 506
6   1o  2v  19 : 268
6   1o  2v  24 : 136
6   2v  1v  4  : 442
6   2v  1v  19 : 374
6   2v  1v  24 : 244
6   2v  3   4  : 786
6   2v  3   19 : 322
6   2v  3   24 : 808
6   2o  1v  4  : 410
6   2o  1v  19 : 176
6   2o  1v  24 : 58
6   2o  3   4  : 264
6   2o  3   19 : 220
6   4   1v  2v : 444
6   4   1v  2o : 258
6   4   1v  19 : 908
6   4   1v  24 : 578
6   4   3   1v : 698
6   4   3   1o : 100
6   4   3   2v : 432
6   4   3   2o : 124
6   4   3   19 : 804
6   4   3   24 : 856
6   4   2v  1v : 530
6   4   2v  1o : 624
6   4   2v  19 : 1132
6   4   2v  24 : 476
6   19  1v  2v : 264
6   19  1v  2o : 390
6   19  1v  4  : 460
6   19  1v  24 : 408
6   19  3   1v : 468
6   19  3   1o : 204
6   19  3   2v : 566
6   19  3   2o : 252
6   19  3   4  : 392
6   19  3   24 : 886
6   19  2v  1v : 234
6   19  2v  1o : 324
6   19  2v  4  : 540
6   19  2v  24 : 522
6   19  2o  24 : 516
6   24  1v  2v : 98
6   24  1v  2o : 184
6   24  1v  4  : 690
6   24  1v  19 : 302
6   24  3   1v : 454
6   24  3   1o : 176
6   24  3   2v : 564
6   24  3   2o : 224
6   24  3   4  : 908
6   24  3   19 : 330
6   24  2v  1v : 82
6   24  2v  1o : 464
6   24  2v  4  : 544
6   24  2v  19 : 290
6   24  2o  19 : 144
19  1v  3   4  : 808
19  1v  3   6  : 322
19  1v  3   24 : 786
19  1v  2v  4  : 244
19  1v  2v  6  : 374
19  1v  2v  24 : 442
19  1o  3   6  : 220
19  1o  3   24 : 264
19  1o  2v  4  : 58
19  1o  2v  6  : 176
19  1o  2v  24 : 410
19  2v  1v  4  : 192
19  2v  1v  6  : 350
19  2v  1v  24 : 638
19  2v  3   4  : 278
19  2v  3   6  : 482
19  2v  3   24 : 568
19  2o  1v  4  : 136
19  2o  1v  6  : 268
19  2o  1v  24 : 506
19  2o  3   6  : 218
19  2o  3   24 : 252
19  4   1v  2v : 82
19  4   1v  2o : 464
19  4   1v  6  : 290
19  4   1v  24 : 544
19  4   1o  6  : 144
19  4   3   1v : 564
19  4   3   1o : 224
19  4   3   2v : 454
19  4   3   2o : 176
19  4   3   6  : 330
19  4   3   24 : 908
19  4   2v  1v : 98
19  4   2v  1o : 184
19  4   2v  6  : 302
19  4   2v  24 : 690
19  6   1v  2v : 234
19  6   1v  2o : 324
19  6   1v  4  : 522
19  6   1v  24 : 540
19  6   1o  4  : 516
19  6   3   1v : 566
19  6   3   1o : 252
19  6   3   2v : 468
19  6   3   2o : 204
19  6   3   4  : 886
19  6   3   24 : 392
19  6   2v  1v : 264
19  6   2v  1o : 390
19  6   2v  4  : 408
19  6   2v  24 : 460
19  24  1v  2v : 530
19  24  1v  2o : 624
19  24  1v  4  : 476
19  24  1v  6  : 1132
19  24  3   1v : 432
19  24  3   1o : 124
19  24  3   2v : 698
19  24  3   2o : 100
19  24  3   4  : 856
19  24  3   6  : 804
19  24  2v  1v : 444
19  24  2v  1o : 258
19  24  2v  4  : 578
19  24  2v  6  : 908
24  1v  3   4  : 470
24  1v  3   6  : 262
24  1v  3   19 : 708
24  1v  2v  4  : 370
24  1v  2v  6  : 172
24  1v  2v  19 : 650
24  1o  3   4  : 220
24  1o  3   6  : 802
24  1o  3   19 : 264
24  1o  2v  4  : 270
24  1o  2v  6  : 558
24  1o  2v  19 : 414
24  2v  1v  4  : 370
24  2v  1v  6  : 272
24  2v  1v  19 : 494
24  2v  3   4  : 610
24  2v  3   6  : 876
24  2v  3   19 : 460
24  2o  1v  4  : 200
24  2o  1v  6  : 174
24  2o  1v  19 : 310
24  2o  3   4  : 218
24  2o  3   6  : 850
24  2o  3   19 : 252
24  4   1v  2v : 158
24  4   1v  2o : 230
24  4   1v  6  : 240
24  4   1v  19 : 552
24  4   1o  19 : 516
24  4   3   1v : 616
24  4   3   1o : 426
24  4   3   2v : 348
24  4   3   2o : 446
24  4   3   6  : 352
24  4   3   19 : 826
24  4   2v  1v : 308
24  4   2v  1o : 312
24  4   2v  6  : 146
24  4   2v  19 : 1346
24  6   1v  2v : 300
24  6   1v  2o : 460
24  6   1v  4  : 330
24  6   1v  19 : 416
24  6   1o  19 : 504
24  6   3   1v : 940
24  6   3   1o : 110
24  6   3   2v : 688
24  6   3   2o : 122
24  6   3   4  : 806
24  6   3   19 : 2310
24  6   2v  1v : 582
24  6   2v  1o : 360
24  6   2v  4  : 288
24  6   2v  19 : 904
24  6   2o  19 : 1008
24  19  1v  2v : 328
24  19  1v  2o : 540
24  19  1v  4  : 314
24  19  1v  6  : 532
24  19  1o  4  : 144
24  19  1o  6  : 504
24  19  3   1v : 192
24  19  3   1o : 600
24  19  3   2v : 608
24  19  3   2o : 614
24  19  3   4  : 336
24  19  3   6  : 2372
24  19  2v  1v : 280
24  19  2v  1o : 566
24  19  2v  4  : 790
24  19  2v  6  : 1410
24  19  2o  6  : 1008
'notte
   Pierpaolo

...
A questo punto che dire?  WITH COMPLIMENTS!!!
.
A parte quei due o
tre anni che impiegheremo a verificare la massa dei tuoi dati, il problema
direi che e' risolto!
Anche la scomposizione nei quattro sottoproblemi in
funzione della posizione del pezzo neutro e' un uovo di colombo. Permette
di avere 4 semplici gruppi di soluzioni in numero inferiore a 100.000.
Sicuramente ora le quattro soluzioni sono verificabili con il solver di
Gerard Putter e probabilmente con altri. Mi ricorda la soluzione dei
pentamini negli anni sessanta, se non erro, fatta scomponendo il problema
per ogni posizione del pezzo 'U'. La dimostrazione che sono solo 4 le
posizioni possibili del pezzo neutro e' facile.
Ora vado in ferie senza
PC. Son quasi sicuro che al mio ritorno ci saranno gia' tutte le conferme
del caso!
.
Ciao a tutti, bel thread!



.
Deve esserci pero' qualche problema di riflessione o definizione: non
riesco a far coincidere la tua tabella con la nostra. Riesci ad allinearla
in base al disegno che definisce le colonne A,B,C e D? Il metodo di Dario e
il mio sono diversi, eppure coincidono, S.E.&O.
.
Ciao  :o))



,
.
.
.
Intanto ti
confermo il risultato di 5.928 ottenuto con il Gerard's Solver in 3522
secondi su un pentium della madxxxx  :)
.
Ciao  :o)


 secondi su un pentium della madxxxx  :)
Uff! Meno male. Non č che fossi poi cosě sicuro...
Ciao

 il mio sono diversi, eppure coincidono, S.E.&O.
Sģ, l'ho notato.  C'č qualche riga che coincide e altre diverse.  Spero
che si tratti di un banale problema di riflessioni o simili.
La tabella l'ho ottenuta analizzando le soluzioni, non rifacendo il
calcolo come lo state facendo voi. Effettivamente, i pezzi agli
angoli sono quelli che risultano a Dario, ma le permutazioni
non coincidono.  Potrei aver sbagliato a normalizzarle, o in altri
cento modi.  Come ho gią detto, ho molta maggiore confidenza
nelle soluzioni trovate, che nella tabella, che č un po' accroccata.
Io cercherņ di pensarci un po' su, a come riconciliare i risultati
diversi.  Nel frattempo, posso mandare il file delle soluzioni a
te (vabbč, tu vai in vacanza, beato te) e a Dario (e a chiunque
altro fosse interessato), nel caso che vogliate provare ad
analizzarle a modo vostro. Zippato č circa 2 mega.
Ciao
  Pierpaolo

 secondi su un pentium della madxxxx  :)
A quanti Mhz corrisponde una 'xxxonna'?     8-)
P.

...
.
Lo ricevo volentieri se lo spedisci qua:
.
edi...@yahoo.com
.
cosi' son sicuro che ci sta. Lo pubblico anche
rendendolo downloadabile per il resto del mondo, se sei d'accordo, magari
dopo che abbiamo terminato le prove del nove e siamo certissimi dei
risultati.
.
Non sarebbe male, anche, se scrivessi due righe di come hai
fatto, per sommi capi, come hanno gia' fatto altri autori sul mio sito. Se
poi fosse pure in inglese...  :o)
.
Ciao, a presto!


 poi fosse pure in inglese...  :o)
OK, I'll see what I can come up with.  But I assure you
there's nothing in the program worth mentioning. No
secret techniques, no dirty tricks,  just a bit of brute force
applied on the right spot  8-).  In addition to the solutions,
I have nothing in contrary in making the program itself
public.
Ciao

 verificare con un altro solver.
Il prog. piazza i pezzi in un ordine fisso, cioè questo:
    nnnn ffff mmmm fnff mnff fnfm mnfm fnmf mnmf
    fnmm mnmm mfmf fnfn mnmn mfff mffm mfmm
    mnfn fnnf mnnf fnnm mnnm fnnn mnnn
quindi, tutte le soluzioni che hanno, per esempio, i pezzi
nnnn ffff mmmm in posizione fisse, sono contigue nel file
delle soluzioni.
Per esempio:
di soluzioni con nnnn in (1,1), ffff in (2,2), e mmmm in (1,2)
ce ne sono 880.
con nnnn in (1,1), ffff in (2,2), mmmm in (1,2), fnff in (6,1)
ce ne sono 28.
lo stesso, ma con fnff in (6,2), 46 soluzioni, ecc.
Puoi trovarti tutti i sottocasi che vuoi con abbastanza vincoli
da poter essere risolti in poco tempo con il solver che usi.
Se riesco a mandarti 'ste soluzioni.  Ho riprovato mentre
stavo scrivendo questo, ma ancora non va.
'notte
  Pierpaolo

 verificare con un altro solver.
Il prog. piazza i pezzi in un ordine fisso, cioè questo:



,
Purtroppo ho trovato
solamente 4344 soluzioni per il neutro in (1,2), che e' esattamente la
meta'...
Aspetto conferme. O riflessioni sulle riflessioni :o)
.
Ciao
:o)


.
.
.
.
.
Ops... tagliato ramo verde invece di uno secco   :o)))
.
Confermo
8688 !!!!!!!!!!!!!!!!!!!!!!!!!
,
Ciao e scusa Pierpaolo, io sono un uomo
di poca, poca fede!  ;o)


 di poca, poca fede!  ;o)
Non c'è bisogno di scuse, ovviamente.
Ci stiamo divertendo, no?
Se ti sei scaricato i files, queste soluzioni sono quelle
da 71.993 a 80.680.
Ciao   8-)
Pierpaolo


,
Esaminata la soluzione
(2,1) di 61.320.
Con il neutro in (2,1), posso inserire in (1,1) soltanto
il pezzo 1 opp. il pezzo 2. Li fisso alternativamente ed ottengo con il
solito solver 30.660 soluzioni cadauno con una simmetria spettacolare.
(Meditare)
.
Quindi 61.320 e' confermato !!!!!!!!!!!!!!
.
Il pentium
della madxxxx che ha lavorato la notte per trovare la sol. da 71,000 e'
letteralmente schiattato! Vi consiglio di non provarci con il Gerard's
solver in Java perche' penso che il problema sia in I.E. (cioe', quando il
num. delle sol. e' cosi' grande da far intervenire la mem. virtuale, I.E.
si inchioda, e in un certo senso e' anche giusto, se no sarebbe una back-
door per far scrivere su disco un applet Java [OT], chi ha orecchie per
intendere, intenda.)
Se qualcuno volesse provare durante la mia assenza,
che se Nettuno vuole, comincera' stanotte, consiglio di spezzare il
problema in otto, associando la posizione relativa, ad es., del pezzo MMMM.
.
A proposito, mi tocchera' una traversata notturna in vela, e come non
potro' pensare a colei che:
.
"Lavorera' con l'ago tutta notte
per
aggiustar le mutande rotte?"
.
.
Ciao a tutti e buone vacanze  :o)


 che se Nettuno vuole,
StraROTFL!  (indovina dove sto io in questo momento?
(suggerimento: č un posto circa 60 km a sud di Roma)).
Vai tranquillo: Nettuno č sonnacchioso e distratto.
Ciao,
  Pierpaolo