Cappelli tricolori

[axpgn]

Tu e tuoi sei amici matematici avete un cappello in testa.
Ognuno può vedere i cappelli degli altri ma non il proprio.
Ci sono nove cappelli in totale, tre rossi, tre gialli e tre verdi ma due sono nascosti.
I vostri amici iniziano a fare le seguenti affermazioni, in sequenza:

Primo: "Non so quale sia il colore del mio cappello"
Secondo: "Anch'io non so quale sia il colore del mio cappello"
Terzo: "Anch'io non so quale sia il colore del mio cappello"
Quarto: "Io so che il mio cappello è rosso"
Quinto: "Ancora non so quale sia il colore del mio cappello"
Sesto: "Io so che il mio cappello è giallo"

Siete in grado di determinare il colore del vostro cappello?



Cordialmente, Alex

[Quinzio]

Credo di aver trovato l'errore che facevo nella mia lista con esclusioni successive.

A fronte dell'affermazione non so, fatta ad es. dal giocatore 1, si eliminano le disposizioni dove C1 = C8 = C9.
(C8 e C9 sono i cappelli/giocatori nascosti).

A fronte dell'affermazione di C4 "Il mio colore e' X" si prendono in considerazione le disposizioni dove C4 = X e se esiste, distinta, anche un'altra delle disposizioni dove C4, C8, C9 sono scambiati allora si eliminano tutte.
Ovvero se nella lista, oltre a C1 C2 C3 C4 C5 C6 C7 C8 C9 esiste anche C1 C2 C3 C9 C5 C6 C7 C8 C4, si cancellano tutte e due.
Questo perche' se esistono almeno due disposizioni fatte cosi', il giocatore 4 non puo' essere certo del suo colore, quindi si eliminano.
Chiaramente se C4=C8=C9, cambiare l'ordine di questi 3 elementi porta alla stessa disposizione, quindi va tenuta.

L'errore che facevo era di tenere solo quelle dove C4=C8=C9.

Con questo ragionamento dovrebbe essere possibile potare la lista fino ad arrivare al giocatore 7 che abbia la certezza del suo colore.

[Quinzio]

Questa e' la lista completa delle disposizioni.
A breve metto anche il programmino in C++ che genera la lista, se qualcuno e' interessato.
Soprattutto metto le idee per fare il programma.
Comunque da controllare a mano che una disposizione passa tutti i filtri (le affermazioni degli amici) e' un compito abbastanza difficile.
Gia' fare il programmino non e' banale.

In definitiva, si, il settimo sa il suo colore che e' il verde.

La regola semplice per generare la lista completa sembra essere:
Ci sono 2 rossi nei primi 3 oppure i primi 3 sono tutti diversi.

   7)  R R G R G G V nasc  V V
   8)  R R V R V G V nasc  G G
  11)  R R G R V G V nasc  G V
  12)  R R V R G G V nasc  V G
  45)  R G R R G G V nasc  V V
  46)  R V R R V G V nasc  G G
  49)  R G R R V G V nasc  G V
  50)  R V R R G G V nasc  V G
  96)  G R R R G G V nasc  V V
  97)  V R R R V G V nasc  G G
 100)  G R R R V G V nasc  G V
 101)  V R R R G G V nasc  V G
 128)  R G V R G G V nasc  R V
 130)  R V G R V G V nasc  R G
 136)  R G V R V G V nasc  R G
 138)  R V G R G G V nasc  R V
 140)  G R V R G G V nasc  R V
 143)  V R G R V G V nasc  R G
 152)  G R V R V G V nasc  G R
 155)  V R G R G G V nasc  V R
 157)  G V R R G G V nasc  V R
 159)  V G R R V G V nasc  G R
 165)  G V R R V G V nasc  G R
 167)  V G R R G G V nasc  V R

[reda99]

Mio malgrado mi sono reso conto di essere clamorosamente arrugginto con il PROLOG.
Lascio una soluzione ottenuta con Mathematica.

Genera tutte le possibili permutazioni.
p = Permutations[{r, r, r, g, g, g, v, v, v}, {7}];
Seleziona solo quelle conformi alle affermazioni:
numero 4 dice rosso e numero 6 dice giallo.
s1 = Select[p, #[[4]] == r && #[[6]] == g &];
Il numero 4 dice rosso perché ha visto 2 rossi.
Seleziona solo i casi che contengono 2 rossi nei primi 3
s2 = Select[s1, Count[Take[#, 3], r] == 2 &];
Il numero 6 dice giallo perché ha visto 2 gialli.
Seleziona solo i casi che contengono 2 gialli nei primi 5.
Visualizza il risultato.
TableForm[Select[s2, Count[Take[#, 5], g] == 2 &]]

Una nota finale:
di solito si specifica che le persone sono incappucciate ed il cappuccio viene tolto una persona alla volta.
Così come è stato enunciato potrebbe essere possibile che tutti vedano tutti simultaneamente, ciò "sballerebbe" completamente le condizioni per la soluzione che ho proposto

[Quinzio]

"Quinzio":Questa e' la lista completa delle disposizioni.

Il programma se qualcuno vuole giocarci.

https://onlinegdb.com/hYfKCgwAY

#include <iostream>
#include <bits/stdc++.h>
using namespace std;

vector<int> hats;
vector<int> pl;
vector<vector<int>> blob;
int depth;

void f() {
    if (depth == 7) {
        for (int hid_hats = 0; hid_hats < 3; hid_hats++) {
            while (hats[hid_hats] > 0) {
                hats[hid_hats]--;
                pl.push_back(hid_hats);
            }
        }
        hats[pl[7]]++;
        hats[pl[8]]++;
        pl.push_back(0); // this is the cancelled flag
        blob.push_back(pl);
        pl.pop_back();
        pl.pop_back();
        pl.pop_back();
        return;
    }
    for (int ix = 0; ix < 3; ix++) {
        if (hats[ix] > 0) {
            hats[ix]--;
            pl.push_back(ix);
            depth++;
            f();
            depth--;
            pl.pop_back();
            hats[ix]++;
            if (hats[ix] == 3) {
                break;
            }
        }
    }
}

vector<int> renumber(vector<int> v) {
    vector<int> res(9);
    vector<int> pos(3);
    pos[0] = pos[1] = pos[2] = -1;
    for (int ix = 0; ix < 9; ix++) {
        for (int num = 0; num < 3; num++) {
            if ((v[ix] == num) && (pos[num]) < 0) {
                pos[num] = ix;
            }
        }
    }
    sort(pos.begin(), pos.end());
    for (int ix = 0; ix < 9; ix++) {
        for (int num = 0; num < 3; num++) {
            if (v[ix] == v[pos[num]]) {
                res[ix] = num;
            }
        }
    }
    return res;
}

int main()
{
    vector<int> unique_pol_vect = {0,0,0,1,0,1,1};
    hats.push_back(3);
    hats.push_back(3);
    hats.push_back(3);
    depth = 0;
    f();

    for (int filter_ix = 0; filter_ix < 7; filter_ix++) {
        // apply filter position 0
        int filter = filter_ix;
        bool unique_pol = unique_pol_vect[filter_ix]; // to satisfy filter... 0: wanted not unique, 1: wanted unique
        bool is_unique = 0;
        bool filter_sat = 0;
#define CANCEL_FLAG 9
        cout << endl << endl << "Remaining before filter... " << filter << endl;
        for (int ix = 0; ix < (int)blob.size(); ix++) {
            if (blob[ix][CANCEL_FLAG] == 0) { // not cancelled
                printf("%4d) ", ix);
                for (int iy = 0; iy < 10; iy++) {
                    printf("%2d", blob[ix][iy]);
                }
                printf("\n", ix);
            }
        }
        cout << endl << endl << "Filter " << filter << endl;
        for (int ix = 0; ix < (int)blob.size(); ix++) {
            if (blob[ix][CANCEL_FLAG] == 0) { // not cancelled
                vector<int> B_AC, C_AB, hid;
                int pos_B_AC = -1, pos_C_AB = -1;
                bool exists_B_AC=false, exists_C_AB=false;
                // build vector B_ordAC
                B_AC = vector<int>(blob[ix].begin(), blob[ix].begin()+7);
                B_AC[filter] = blob[ix][7];
                hid.push_back(blob[ix][filter]);
                hid.push_back(blob[ix][8]);
                B_AC.insert(B_AC.end(), hid.begin(), hid.end());
                B_AC = renumber(B_AC);
                sort(B_AC.begin()+7, B_AC.begin()+9);
                // build vector C_ordAB
                C_AB = vector<int>(blob[ix].begin(), blob[ix].begin()+7);
                C_AB[filter] = blob[ix][8];
                hid.resize(0);
                hid.push_back(blob[ix][filter]);
                hid.push_back(blob[ix][7]);
                C_AB.insert(C_AB.end(), hid.begin(), hid.end());
                C_AB = renumber(C_AB);
                sort(C_AB.begin()+7, C_AB.begin()+9);
                // check if exists B_AC
                for (int iy = 0; iy < (int)blob.size(); iy++) {
                    if (blob[iy][CANCEL_FLAG] == 0) { // not cancelled
                        bool exists = true;
                        for (int iz = 0; iz < 9; iz++) {
                            if (blob[iy][iz] != B_AC[iz]) {
                                exists = false;
                                break;
                            }
                        }
                        if (exists == true) {
                            exists_B_AC = true;
                            pos_B_AC = iy;
                            break;
                        }
                    }
                }
                // check if exists C_AB
                for (int iy = 0; iy < (int)blob.size(); iy++) {
                    if (blob[iy][9] == false) {
                        bool exists = true;
                        for (int iz = 0; iz < 9; iz++) {
                            if (blob[iy][iz] != C_AB[iz]) {
                                exists = false;
                                break;
                            }
                        }
                        if (exists == true) {
                            exists_C_AB = true;
                            pos_C_AB = iy;
                        }
                    }
                }
                // check uniqueness
                if (blob[ix][7] == blob[ix][8]) {
                    if (blob[ix][filter] == blob[ix][8]) {
                        is_unique = true;
                    } else {
                        is_unique = !exists_B_AC;
                    }
                } else {
                    if (blob[ix][filter] == blob[ix][7]) {
                        is_unique = !exists_C_AB;
                    } else {
                        if (blob[ix][filter] == blob[ix][8]) {
                            is_unique = !exists_B_AC;
                        } else {
                            is_unique = !exists_B_AC && !exists_C_AB;
                        }
                    }
                }
                // apply polarity
                filter_sat = is_unique == unique_pol;
                if (filter_sat == false) {
                    cout << "Cancelling " << ix << endl;
                    blob[ix][CANCEL_FLAG] = 1; // cancelled
                    if (exists_B_AC) {
                        cout << "Cancelling " << pos_B_AC << endl;
                        blob[pos_B_AC][CANCEL_FLAG]++; // cancelled
                    }
                    if (exists_C_AB) {
                        cout << "Cancelling " << pos_C_AB << endl;
                        blob[pos_C_AB][CANCEL_FLAG]++; // cancelled
                    }
                }
            }
        }
    }
    cout << endl << endl << "Colori " << endl;
    for (int ix = 0; ix < (int)blob.size(); ix++) {
        if (blob[ix][CANCEL_FLAG] == 0) { // not cancelled
            vector<int> col(3);
            col[0] = blob[ix][5]; // giallo
            col[1] = blob[ix][6]; // verde
            col[2] = blob[ix][3]; // rosso
            printf("%4d) ", ix);
            for (int iy = 0; iy < 9; iy++) {
                char let;
                if (blob[ix][iy] == col[0]) let = 'G';
                if (blob[ix][iy] == col[1]) let = 'V';
                if (blob[ix][iy] == col[2]) let = 'R';
                if (iy == 7) printf(" nasc ");
                printf(" %c", let);
            }
            printf("\n", ix);
        }
    }
    cout << "Hello World!" << endl;
    return 0;
}

[utente__medio11]

Mi sono cimentato anche io nell'implementazione del problema, ma l'ho risolto dal punto di vista dei giocatori, ossia, fornita la sequenza di colori, il programma restituisce la sequenza di affermazioni fatte dai vari giocatori.
Un giocatore deduce il proprio colore quando ha a disposizione un'unica alternativa; le alternative a sua disposizione potrebbero ridursi se un'ipotesi sul proprio colore producesse affermazioni/deduzioni diverse da parte dei giocatori precedenti.

Ecco il codice in C++:

#include <iostream>
#include <vector>

using namespace std;

const unsigned int G = 7;//NUMERO GIOCATORI
const unsigned int C = 3;//NUMERO COLORI
const unsigned int M = 3;//MASSIMO OCCORRENZE COLORE
const char c[C] = {'G', 'R', 'V'};//ELENCO COLORI

void definisci_alternative_giocatori(vector<unsigned int> *a, const unsigned int *s, const unsigned int g)
{
    unsigned int o[C] = {};//CONTEGGIO OCCORRENZE COLORI
    for(unsigned int i = 0; i < G; ++o[s[i++]]);
    for(unsigned int i = 0; i < g; ++i)
    {
        for(unsigned int j = 0; j < C; ++j)
        {
            if(j == s[i] || o[j] != M)
            {
                a[i].push_back(j);
            }
        }
    }
}

bool fun(const unsigned int *s, unsigned int *d, const unsigned int g)
{
    vector<unsigned int> a[G];//ALTERNATIVE GIOCATORI
    definisci_alternative_giocatori(a, s, g);
    for(unsigned int i = 0; i < g; ++i)
    {
        if(i && a[i].size() > 1)
        {
            for(unsigned int j = 0; j < a[i].size(); ++j)
            {
                if(a[i][j] != s[i])
                {
                    unsigned int s_ip[G];//SEQUENZA IPOTETICA
                    for(unsigned int k = 0; k < G; s_ip[k] = k == i ? a[i][j] : s[k], ++k);
                    if(!fun(s_ip, d, i))
                    {
                        a[i].erase(a[i].begin() + j--);
                    }
                }
            }
        }
        if(a[i].size() == 1)
        {
            if(g == G)
            {
                d[i] = a[i][0];
            }
            else if(d[i] != a[i][0])
            {
                return false;
            }
        }
        else if(g != G && d[i] != C)
        {
            return false;
        }
    }
    return true;
}

int main()
{
    char str[G + 1] = "VRRRGGV";//INPUT SEQUENZA COLORI GIOCATORI

    unsigned int s[G];//SEQUENZA COLORI GIOCATORI
    unsigned int d[G];//DEDUZIONI GIOCATORI(IL VALORE "C" INDICA "NON SO", VALORI MINORI INDICANO I CORRISPETTIVI ELEMENTI DI "c")
    for(unsigned int i = 0, j; i < G; s[i] = j, d[i++] = C)
    {
        for(j = 0; c[j] != str[i]; ++j);
    }
    fun(s, d, G);
    for(unsigned int i = 0; i < G; ++i)
    {
        cout << "GIOCATORE " << i + 1 << ": " << c[s[i]] << " -> " << (d[i] == C ? '?' : c[d[i]]) << "\n";
    }
}

Questo l'output:

GIOCATORE 1: V -> ?
GIOCATORE 2: R -> ?
GIOCATORE 3: R -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: G -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V

Process returned 0 (0x0)   execution time : 0.013 s

Dove [inline]GIOCATORE x: y -> z[/inline] indica che il giocatore numero [inline]x[/inline], che ha in testa un cappello di colore [inline]y[/inline], ha fatto l'affermazione [inline]z[/inline] (che può essere o il colore dedotto, o [inline]?[/inline] se non è stato in grado di dedurlo).

"axpgn":[quote="utente__medio"][quote="axpgn"]il fatto è che la dimostrazione della mia soluzione "smonta" la tua soluzione e quindi una delle due è sbagliata ... e siccome la mia è giusta ...

Queste per esempio perché non vanno bene?
GVRRVGV
GRVRVGV
RGVRVGV
RVGRVGV
VGRRVGV
VRGRVGV[/quote]
Ho dimostrato che c'è un solo cappello verde dal secondo al settimo ed è il settimo quindi il quinto non può avere il cappello verde[/quote]
Quelle sequenze di colori se date in pasto al programma restituiscono la stessa sequenza di affermazioni/deduzioni.
Quale vincolo dovrei aggiungere al mio programma affinché esso restituisca una sequenza di deduzioni diversa?



P.S.
Ovviamente il programma può essere facilmente modificato per restituire tutte le sequenze di colori associate ad una specifica sequenza di deduzioni.

[axpgn]

Io non ho idea di cosa dovresti aggiungere al TUO programma

Mi ripeto: "Ho dimostrato che c'è un solo cappello verde dal secondo al settimo ed è il settimo quindi il quinto non può avere il cappello verde"

E quindi ti chiedo: pensi che sia sbagliata? Se è corretta il quinto NON può avere il cappello verde.

[utente__medio11]

Ti traduco la mia precedente richiesta: per caso sai quale dovrebbe essere la sequenza di affermazioni/deduzioni associata per esempio alla sequenza "GVRRVGV"?
Se non lo sai o non hai voglia di pensarci allora semplicemente ignora la mia domanda...

[reda99]

Pensavo di aver finito mostrando come anche con altre ipotesi la soluzione fosse sempre il colore "innominato".

Visto che continuate mi sembra il caso di scrivere il mio ragionamento, non pretende di essere una dimostrazione, non richiede disegnini o grafici, solo poche righe.

Tutti vedono tutti allo stesso momento, tutti sono "knight"

I numeri 1, 2 e 3 tacciono perché ognuno dei tre vede almeno un cappello di ogni colore.

Il terzo è il primo a cantare e canta rosso perchè non vede altri cappelli rossi quindi i due esclusi, o nascosti che dir si voglia, devono essere rossi.

Il quarto sa di sicuro che il suo cappello non è rosso ma ancora non è in grado di determinare se il proprio copricapo sia giallo o verde.

Il quinto è il secondo a cantare e canta giallo perché sa che i due nascosti sono rossi e lui vede altri due gialli e nessuno ha detto verde.

Cosa rimane?

[Quinzio]

"utente__medio":Ti traduco la mia precedente richiesta: per caso sai quale dovrebbe essere la sequenza di affermazioni/deduzioni associata per esempio alla sequenza "GVRRVGV"?
Se non lo sai o non hai voglia di pensarci allora semplicemente ignora la mia domanda...

Secondo me ti manca un pezzo di informazione, come mancava a me all'inizio.
Senza scrivere dei papiri lunghi 100 righe, o algoritmi che nessuno legge, provo a spiegare in modo telegrafico come dovrebbe procedere l'algoritmo.

E' come se ci fosse un foglio che gira tra gli amici. All'inizio sul foglio ci sono scritte tutte le sequenze possibili.
Il foglio va all'amico 1.
Egli fa la sua affermazione, e cancella dal foglio le sequenze che non sono compatibili con la sua affermazione.
Poi il foglio passa all'amico 2.
L'amico 2, in base alle sole sequenze scritte sul foglio, fa la sua affermazione e cancella le sequenze che non sono compatibili con la sua affermazione.
Poi il foglio passa all'amico 3, con la lista gia' epurata, e cosi' via.
Ad ogni amico ci sono delle sequenze che muoiono e altre che sopravvivono.
Quando il foglio e' arrivato all'amico 7, anch'esso fa la sua affermazione, e anch'egli cancella dalla lista le sequenze non compatibili.
Se alla fine sul foglio ci sono rimaste delle sequenze, vuol dire che l'amico 7 ha potuto capire il colore del suo cappello, e quindi l'ipotesti "l'amico 7 sa il suo colore" e' vera.
Se non ci sono sequenze rimaste sul foglio, l'ipotesi e' vera.

Questo e' il nocciolo dell'algoritmo, poi va capito bene come fare le cancellazioni.

Secondo me, l'errore che fai, e che facevo io all'inizio, e' di voler capire se una sequenza sopravvive o no, in base alla sola sequenza.
Ma non e' corretto, perche' ogni amico puo' fare la simulazione del foglio che gira in base alle varie affermazioni, e quindi ogni amico ha delle informazioni importanti anche il base a quello che dice il foglio.

Non so, spero almeno che fino a qui ci troviamo tutti d'accordo.

[axpgn]

"utente__medio":Ti traduco la mia precedente richiesta: per caso sai quale dovrebbe essere la sequenza di affermazioni/deduzioni associata per esempio alla sequenza "GVRRVGV"?
Se non lo sai o non hai voglia di pensarci allora semplicemente ignora la mia domanda...

Ah, ok, adesso ho capito, poni il problema inverso ovvero come costruire le costrizioni che portano ad una certa configurazione.
Non saprei, magari ci penso su ...

[utente__medio11]

@Quinzio
avevo letto e più o meno capito l'algoritmo che avevi postato, ma il mio funziona diversamente, ossia, invece di basare le deduzioni sull'elenco di tutte le possibili sequenze di colori (che se ho fatto bene i conti dovrebbero essere $3((7!)/(3! \ 3! \ 1!)+(7!)/(3! \ 2! \ 2!))=1050$), baso le deduzioni sulle alternative (ossia sull'elenco dei possibili colori del proprio cappello) a disposizione dei singoli giocatori.
Il funzionamento preciso è quello che ho spiegato in precedenza:

"utente__medio":Mi sono cimentato anche io nell'implementazione del problema, ma l'ho risolto dal punto di vista dei giocatori, ossia, fornita la sequenza di colori, il programma restituisce la sequenza di affermazioni fatte dai vari giocatori.
Un giocatore deduce il proprio colore quando ha a disposizione un'unica alternativa; le alternative a sua disposizione potrebbero ridursi se un'ipotesi sul proprio colore producesse affermazioni/deduzioni diverse da parte dei giocatori precedenti.

Per esempio, considerando la sequenza "VRRRGGV", abbiamo in partenza, ossia prima di qualsiasi affermazione da parte dei giocatori, le seguenti alternative:

G1 -> G V
G2 -> G R V
G3 -> G R V
G4 -> G R V
G5 -> G V
G6 -> G V
G7 -> G V

In particolare:
- G1, avendo più alternative, non potrà dedurre il proprio colore;
- tocca poi a G2, che, ipotizzando che il suo colore sia uno di quelli a sua disposizione, controllerà se tale ipotesi implicherebbe una deduzione diversa da parte di G1, e in tal caso potrebbe cancellare tale colore dalla lista delle alternative. Alla fine se resta con un'unica alternativa potrà dedurre il suo colore, altrimenti non potrà farlo. Nel caso specifico anche G2 non potrà dedurre il proprio colore;
- tocca poi a G3. Il meccanismo è lo stesso di quello adottato da G2, con la differenza però che, oltre alla deduzione di G1, dovrà controllare anche quella di G2. Nel caso specifico anche G3 non potrà dedurre il proprio colore;
- tocca poi a G4, che applicherà lo stesso procedimento ricorsivo per tutti i giocatori precedenti. In questo caso però egli riuscirà ad escludere le alternative "G" e "V" e potrà quindi dedurre che il suo colore è "R";
- e così via...

Ho aggiunto un controllo che avevo dimenticato di inserire nel codice qui postato. Adesso per esempio per la sequenza di colori "VRGRGGR" ottengo giustamente il seguente output:

GIOCATORE 1: V -> V
GIOCATORE 2: R -> R
GIOCATORE 3: G -> G
GIOCATORE 4: R -> R
GIOCATORE 5: G -> G
GIOCATORE 6: G -> G
GIOCATORE 7: R -> R

Process returned 0 (0x0)   execution time : 0.012 s

Invece le sequenze di colori "VRRRGGV" (data come soluzione dall'OP) e "GVRRVGV" (fornita come possibile soluzione da me) continuano a restituire la stessa sequenza di deduzioni "???R?GV", riportata (escluso il verde finale) come traccia nel post iniziale.
Se la mia soluzione fosse sbagliata significherebbe che per la sequenza di colori "GVRRVGV" almeno uno tra G1, G2, G3 e G5 dovrebbe essere in grado di dedurre il proprio colore, ma in tal caso come? Oppure almeno uno tra G4, G6 e G7 non dovrebbe essere in grado di dedurre il proprio colore, ma qui (e qui) a mio modesto parere ho dimostrato che invece essi sono in grado di farlo.

Che ne pensi del mio algoritmo e del codice? Perché secondo te sbaglio?

------------------------------------------------------------------------------------------------------------------------

"axpgn":Mi ripeto: "Ho dimostrato che c'è un solo cappello verde dal secondo al settimo ed è il settimo quindi il quinto non può avere il cappello verde"

E quindi ti chiedo: pensi che sia sbagliata? Se è corretta il quinto NON può avere il cappello verde.

Ho riletto con attenzione la tua dimostrazione...
In pratica, se G1 non può dedurre che il suo cappello è verde, significa che vede almeno un cappello verde tra i giocatori successivi. Quindi, seguendo l'ordine, il primo giocatore tra G2, G3, G4, G5 e G6 che non vede un cappello verde in testa ai giocatori successivi potrà dedurre che il proprio colore è il verde. Infine, se nessuno dei precedenti lo fa, G7 deduce di avere in testa un cappello verde.

In pratica, volendo generalizzare, abbiamo che se un giocatore non vede cappelli di colore [inline]x[/inline] in testa agli eventuali giocatori successivi, e nessuno degli eventuali giocatori precedenti ha affermato di avere il colore [inline]x[/inline], allora potrà affermare di avere in testa un cappello di colore [inline]x[/inline] per il ragionamento appena fatto.

Non capisco però perché ciò dovrebbe dimostrare che "c'è un solo cappello verde dal secondo al settimo"?!
Penso che le conseguenze che hai tratto dalla dimostrazione siano sbagliate.

------------------------------------------------------------------------------------------------------------------------

P.S.
Per chiunque volesse testare il mio codice basta modificare la riga

char str[G + 1] = "VRRRGGV";//INPUT SEQUENZA COLORI GIOCATORI

inserendo la sequenza di colori tra gli apici.

[axpgn]

"utente__medio":Non capisco però perché ciò dovrebbe dimostrare che "c'è un solo cappello verde dal secondo al settimo"?!
Penso che le conseguenze che hai tratto dalla dimostrazione siano sbagliate.

[utente__medio11]

"axpgn":[quote="utente__medio"]Non capisco però perché ciò dovrebbe dimostrare che "c'è un solo cappello verde dal secondo al settimo"?!
Penso che le conseguenze che hai tratto dalla dimostrazione siano sbagliate.

[/quote]
E cioè? Non sono un esperto nell'interpretazione delle emoji.

[axpgn]

Io dimostro un certo fatto, tu pensi che sia sbagliato ... trova le differenze ...

[utente__medio11]

"axpgn":[quote="utente__medio"]Non capisco però perché ciò dovrebbe dimostrare che "c'è un solo cappello verde dal secondo al settimo"?!
Penso che le conseguenze che hai tratto dalla dimostrazione siano sbagliate.

Io dimostro un certo fatto, tu pensi che sia sbagliato ... trova le differenze ...[/quote]
Tralasciando la tua "affabilità", ho inteso la tua dimostrazione nel seguente modo:

"utente__medio":se G1 non può dedurre che il suo cappello è verde, significa che vede almeno un cappello verde tra i giocatori successivi. Quindi, seguendo l'ordine, il primo giocatore tra G2, G3, G4, G5 e G6 che non vede un cappello verde in testa ai giocatori successivi potrà dedurre che il proprio colore è il verde. Infine, se nessuno dei precedenti lo fa, G7 deduce di avere in testa un cappello verde.

E' corretto?
In tal caso, dal mio punto di vista, ciò dimostra solo che G7 sa di avere un cappello verde.
A questo punto, visto che non ha avuto risposta, ti rifaccio la domanda che ti ho fatto in precedenza: perché ciò dovrebbe dimostrare che c'è un solo cappello verde dal secondo al settimo? Puoi abbassarti al mio livello e spiegarmelo?

Poi già che ci sono tanto vale mettere tutte le carte in tavola, anche a rischio di dire altre(?) sciocchezze!
Dalla mia citazione sopra riportata ho dedotto che

"utente__medio":In pratica, volendo generalizzare, abbiamo che se un giocatore non vede cappelli di colore [inline]x[/inline] in testa agli eventuali giocatori successivi, e nessuno degli eventuali giocatori precedenti ha affermato di avere il colore [inline]x[/inline], allora potrà affermare di avere in testa un cappello di colore [inline]x[/inline]

Ciò dovrebbe significare che se i giocatori si disponessero in fila indiana in modo che ognuno possa vedere solo i giocatori successivi, questo consentirebbe comunque a tre giocatori di indovinare il proprio colore, che sarà appunto il colore che non vedono davanti a loro e che non è stato ancora nominato dai giocatori precedenti.
Quindi per la sequenza di deduzioni "???R?G" riportata nel post iniziale, visto che il verde non è stato nominato, G7 avrebbe potuto indovinarlo anche da bendato.
Dando in pasto al mio programma la sequenza di colori "RGGVRVV" ottengo la sequenza di deduzioni
"??G?RVV", quindi, se fosse corretta, G7 in questo caso non potrebbe indovinare il proprio colore da bendato.

Se qualcuno oltre a farmelo notare mi spiegasse anche il motivo per cui i miei ragionamenti sarebbero sbagliati, gliene sarei grato.

[axpgn]

Il primo che parla se NON vedesse nessun cappello in testa agli altri 6 suoi amici ne dedurrebbe di avere in testa un cappello verde.
D'accordo?
Invece afferma di non sapere il colore del suo cappello e ciò IMPLICA che almeno uno dei suoi 6 compagni ha in testa un cappello verde.
D'accordo?
Il secondo che parla a questo punto SA che o lui o almeno uno dei suoi 5 compagni che non hanno ancora parlato ha un cappello verde in testa.
D'accordo?
Se il secondo NON vedesse un cappello verde in testa ad uno dei suoi 5 amici che non hanno parlato, ne dedurrebbe di avere lui un cappello verde in testa ma invece afferma di non averlo e ciò IMPLICA che almeno uno dei suoi 5 compagni ha un cappello verde in testa.
Lo stesso identico ragionamento si può fare per il terzo che parla il quale quindi non ha un cappello verde in testa.
Il quarto c'è l'ha rosso, per il quinto si può fare lo stesso ragionamento del secondo e del terzo e il sesto c'è l'ha giallo.
Quindi, riassumendo, escluso il primo, almeno uno degli altri ha un cappello verde in testa però il secondo che parla non ce l'ha, il terzo idem così come il quarto, il quinto e il sesto, perciò il settimo HA il cappello verde in testa (ed è l'unico tra i sei)
D'accordo?

[axpgn]

Se il quinto avesse il cappello verde, il settimo non potrebbe sapere il colore del suo

Proseguo qui la dimostrazione che avevo già scritto per Quinzio dove però mi ero fermato al quarto (rosso)

S5 vedrebbe GRRR_YG.
Se S5 assume di avere il verde, S4 avrebbe visto GRR_GYG. Se S4 assume di avere il giallo, S3 avrebbe dedotto di avere il rosso (altrimenti, S3 avrebbe avuto il giallo e S2 avrebbe conosciuto il suo colore come rosso). Dal momento che S3 non ha detto di avere il rosso, S4 saprebbe che non ha il giallo. Quindi S4 concluderebbe e annuncerebbe di avere il rosso. Possiamo anche vedere che, se S5 presume di avere il verde, S1, S2, S3 direbbero tutti che non conoscono i loro colori.
D'altra parte, se S5 presume di avere il giallo, S4 avrebbe visto GRR_YYG. Se S4 assume di avere il verde, S3 avrebbe dedotto il suo colore come rosso (se S3 assume il giallo, S2 avrebbe annunciato il rosso). Se S4 assume il suo colore come giallo, ancora una volta S3 avrebbe dedotto il suo colore come rosso. Pertanto, S4 concluderebbe e annuncerebbe di avere il rosso. Possiamo anche vedere che, se S5 presume di avere il giallo, S1, S2, S3 direbbero tutti che non conoscono i loro colori. C'è più di una scelta di colore per S5 che causerebbe le stesse risposte da S1, S2, S3, S4. Quindi S5 direbbe che non conosce il suo colore.


S6 vede GRRRY_G. Se S6 assume di avere il verde, S5 avrebbe visto GRRR_GG, S5 concludeva e annunciava di avere il giallo, cosa che non ha fatto. Quindi S6 sa di non avere il verde, e concluderebbe e annuncerebbe di avere il giallo.

[84f45e194ee50365c2aa8ead271e4a9d9bb017bb]

@axpgn

"3m0o":

Rappresentiamo i nostri 7 protagonisti come i vertici numerati (in ordine di chi parla) di un eptagono regolare. Ora ciascuno degli amici fa la seguente cosa: dipinge i vertici che vede in accordo con i colori dei cappelli e lascia in nero il vertice corrispondente a se stesso (ciascuno fa un disegno personale). Inoltre congiunge con un arco colorato i vertici con lo stesso colore, dove il colore dell'arco è il colore dei suoi vertici. Risulta piuttosto chiaro che se uno degli amici disegna due triangoli monocromatici allora sa il proprio colore (l'altra direzione è falsa!). Pertanto possiamo escludere che il primo disegni due triangoli poiché non sa il proprio colore. Siccome il primo e il secondo hanno risposto non lo so, significa che il secondo non ha disegnato un triangolo monocromatico e un arco (disgiunti) che hanno come vertici che corrispondono agli amici $3,4,5,6,7$. Infatti assumendo il contrario o il secondo avrebbe il colore del arco e dunque il primo avrebbe saputo rispondere il proprio colore (per quanto detto sopra) oppure il secondo avrebbe dedotto che ha il colore del vertice che corrisponde a $1$. Questo ha come conseguenza che per colorare i vertici $A_1=\{3,4,5,6,7\}$ abbiamo usato tutti e $3$ i colori (verde, giallo e rosso). Con un ragionamento del tutto analogo con $2$ e $3$ e rispettivamente con $1$ e $3$ possiamo dedurre che i vertici $A_2=\{1,4,5,6,7\}$ e rispettivamente $A_3\{2,4,5,6,7\}$ sono colorati usando tutti e $3$ i colori. Pertanto abbiamo due possibilità: o $1,2,3$ formano un triangolo verde, ma in questo caso il $4$ non avrebbe potuto dedurre il proprio colore a meno che $5,6,7$ non formino un triangolo giallo e dunque il $5$ avrebbe dedotto che ha il cappello giallo, dunque questo caso non è possibile. Pertanto in $\{4,5,6,7\}$ c'è il verde. Da cui abbiamo che o il $5$ e il $7$ hanno entrambi lo stesso colore (il verde) oppure hanno colori diversi, ma almeno uno è verde. Nel primo caso abbiamo finito, il $7$ è verde. Assumiamo dunque che hanno colori diversi e assumiamo che il $7$ è giallo. Abbiamo che il $4$ per capire il proprio colore ha disegnato un triangolo e un arco lasciando spaiato un vertice tra $1,2,3$, wlog $1$. Ora $4$ deduce che ha il colore di $1$, altrimenti formerebbe un triangolo con l'arco che $4$ ha colorato e $1$ avrebbe dedotto il proprio colore. In ogni caso l'amico $5$ avrebbe capito il proprio colore era verde: infatti $A_1 \cap A_2 \cap A_3 = \{ 4,5,6,7 \}$ contiene almeno un vertice verde, e $4$ è rosso e $6,7$ gialli. Non va bene poiché $5$ dice non lo so. In conclusione $7$ è verde (e forse si riesce a dedurre anche $5$). Forse ho dimenticato qualche cosa, ma non mi sembra.

Il cappello del quinto può essere verde! Dal fatto che i primi 3 rispondono 'non lo so' si può concludere soltanto che tra il quarto e il settimo (compresi) (quindi in \(\{4,5,6,7\}\)) c'è almeno un cappello verde, uno giallo e uno rosso. Sapendo che il quarto e il sesto lo hanno rispettivamente rosso e giallo allora c'è almeno un cappello verde tra il quinto e il settimo. Il settimo lo deve per forza avere verde, perché se il settimo lo avesse giallo o rosso allora il quinto saprebbe di averlo verde e non può rispondere "non so". Infatti il fatto che il quinto risponde "non lo so" ti dice che nel insieme \( \{4,6,7\} \) c'è esattamente uno rosso, uno verde e uno giallo, ma nulla puoi dedurre sul colore del quinto. Infatti il quinto può averlo verde, vedere il settimo verde e non sapere di averlo verde. Ad esempio questa assegnazione di colori mi sembra che funziona
1) Giallo
2) Verde
3) Rosso
4) Rosso
5) Verde
6) Giallo
7) Verde

In effetti il primo vede un triangolo verde (vertici \(1,2,5\)) un arco rosso (vertici \(3,4\) ) e un vertice, il \(6\), giallo. Pertanto non sa scegliere tra rosso e giallo. Il secondo vede tre archi, uno verde con vertici \(5,7\), uno rosso con vertici \(3,4\) e uno giallo con vertici \(1,6\) e non può scegliere a quale appartenere e dice non lo so. Il terzo invece vede un arco giallo con vertici \(1,6\) e un triangolo verde di vertici \(2,5,7\) e un punto rosso il vertice \(4\). Il fatto è che l'arco contiene il vertice \(1\) quindi è compatibile con il fatto che il primo dica "non lo so" e il triangolo contiene il vertice \(2\) che a sua volta è compatibile con il fatto che il secondo dica "non lo so". Pertanto il terzo non può sapere se appartenere al arco (avere il cappello giallo) oppure essere dello stesso colore del quarto (rosso) e dice non lo so. Adesso il quarto vede un triangolo verde di vertici \(2,5,7\) e un arco giallo di vertici \(1,6\). Sicuramente non ha il colore giallo poiché altrimenti il terzo avrebbe potuto identificare il proprio colore, non lo ha nemmeno verde perché sono già esauriti tutti i cappelli verdi, dunque lo ha del colore del terzo, ovvero rosso. E quindi il quarto dice rosso.
A questo punto il quinto vede 3 archi, \(1,6\) è giallo, \(7,2\) è verde e \(3,4\) è rosso. Può escludere di averlo rosso poiché altrimenti il quarto non sarebbe stato in grado di determinare il proprio colore, ma non può decidere se ha il cappello giallo oppure verde perché sono entrambi compatibili con il fatto che i primi tre abbiano risposto "non lo so" e il quarto rosso, dunque dice non lo so. Ora il sesto sa di avere il cappello giallo poiché vede che il quarto lo ha rosso, il quinto e il settimo lo hanno verde e sa che ci dev'essere per forza un cappello giallo tra i vertici \(4,5,6,7\) poiché i primi tre hanno detto "non lo so" e dunque il sesto dice giallo. A questo punto il settimo deduce di averlo verde, poiché se lo avesse rosso o giallo, il quinto avrebbe identificato il proprio colore.

Ps: ho usato il seguente fatto: Dati due vertici distinti \(v, w \in \{1,2,3,4,5,6,7\} \). Se ci sono un triangolo e un arco, che non condividono vertici, entrambi monocromatici e con vertici in \( \{1,2,3,4,5,6,7\} \setminus \{v,w\} \) allora \(v\) o \(w\) può determinare il proprio colore. La dimostrazione con \(v=1,w=2\) la do nella mia risposta in spoiler che ho citato, ma si applica a qualunque coppia di vertici disgiunti.

[84f45e194ee50365c2aa8ead271e4a9d9bb017bb]

"axpgn":Il primo che parla se NON vedesse nessun cappello in testa agli altri 6 suoi amici ne dedurrebbe di avere in testa un cappello verde.
D'accordo?

Sì, d'accordo

"axpgn":
Invece afferma di non sapere il colore del suo cappello e ciò IMPLICA che almeno uno dei suoi 6 compagni ha in testa un cappello verde.
D'accordo?

Sì, d'accordo, quindi implica che c'è almeno un verde in \( \{2,3,4,5,6,7\} \).

"axpgn":
Il secondo che parla a questo punto SA che o lui o almeno uno dei suoi 5 compagni che non hanno ancora parlato ha un cappello verde in testa.
D'accordo?

Sì, d'accordo (nota che anche il primo o il secondo potrebbe averlo verde, ma okay sono d'accordo perché di sicuro il secondo vede almeno un verde in \( \{3,4,5,6,7\} \subseteq \{1,3,4,5,6,7\} \))

"axpgn":
Se il secondo NON vedesse un cappello verde in testa ad uno dei suoi 5 amici che non hanno parlato, ne dedurrebbe di avere lui un cappello verde in testa ma invece afferma di non averlo e ciò IMPLICA che almeno uno dei suoi 5 compagni ha un cappello verde in testa.

Non sono d'accordo, il secondo afferma di non sapere il proprio colore, non dice di non avere il cappello verde! E questo implica che vede almeno un cappello verde in \( \{3,4,5,6,7\} \subseteq \{1,3,4,5,6,7\} \).

"axpgn":
Lo stesso identico ragionamento si può fare per il terzo che parla il quale quindi non ha un cappello verde in testa.

Non sono d'accordo, il ragionamento si applica anche al terzo su questo okay! Però, non vuol dire che il terzo non ha il cappello verde! Quello che puoi concludere è che il terzo vede almeno un cappello verde in \( \{4,5,6,7\} \subseteq \{1,2,4,5,6,7\} \).

"axpgn":
Il quarto c'è l'ha rosso, per il quinto si può fare lo stesso ragionamento del secondo e del terzo e il sesto c'è l'ha giallo.

Sì, ma con la correzione di cui sopra. Anche il quinto può avere il cappello verde, così come il primo, il secondo o il terzo. Nulla lo vieta in questo ragionamento che hai esposto.

"axpgn":
Quindi, riassumendo, escluso il primo, almeno uno degli altri ha un cappello verde in testa però il secondo che parla non ce l'ha, il terzo idem così come il quarto, il quinto e il sesto, perciò il settimo HA il cappello verde in testa (ed è l'unico tra i sei)
D'accordo?

Non sono d'accordo (sul unicità)! Piuttosto direi, quindi riassumendo il settimo ha il cappello verde perché è nel intersezione seguente (cioè visto dal primo, dal secondo, dal terzo e dal quinto): \[ \{2,3,4,5,6,7\} \cap \{1,3,4,5,6,7\} \cap \{1,2,4,5,6,7\} \cap \{1,2,3,4,6,7\} = \{4,6,7\}. \]
Inoltre in ognuno di questi insiemi c'è almeno un cappello verde (per il ragionamento tuo sopra) quindi anche nella loro intersezione c'è ne è almeno uno verde. Ora il \(4\) lo ha rosso, e il \(6\) lo ha giallo per cui il \(7\) è verde. Ma questo non vuol dire che è l'unico verde in \( \{1,2,3,5,7\} \).

NB: il tuo ragionamento è indipendente dal colore, puoi ripeterlo con il rosso e il giallo, quindi puoi concludere che in \(\{4,6,7\} \) c'è un cappello rosso, uno giallo e uno verde. Anche se lo sappiamo già, ma immagina che non sapessimo le risposte di \(4\) e \(6\), o meglio sappiamo che hanno capito il loro cappello ma non sappiamo di che colore lo hanno perché magari hanno detto "io l'ho capito" invece di dire il colore. Beh allora saremmo certi che in \( \{4,6,7\} \) c'è uno rosso, uno giallo e uno verde, siamo solo insicuri sul ordine (l'informazione del $4$ rosso e del $6$ giallo ci permette di fissare l'ordine e dedurre che il verde è il $7$). Il primo di sicuro vede almeno un rosso in \( \{2,3,4,5,6,7\} \) altrimenti saprebbe il proprio colore, e così via con il secondo vede almeno un rosso in $\{1,3,4,5,6,7\}$, etc. Uguale con il giallo lo puoi fare. Però di sicuro i cappelli \( \{4,6,7\} \) non sono gli unici rossi, gialli e verdi, perché di sicuro anche in \( \{1,2,3,5\} \) ci sono almeno due colori tra il rosso, giallo e verde. Se il tuo ragionamento portasse (cosa che non fa) a dire che il \(7\) è l'unico verde, allora lo stesso ragionamento si applicherebbe per dire che il \(4\) sarebbe l'unico rosso e il \(6\) l'unico giallo, cosa palesemente falsa.

"axpgn":Se il quinto avesse il cappello verde, il settimo non potrebbe sapere il colore del suo

Anche questo non è corretto! Il settimo lo può capire per il discorso di prima. Sa che in \( \{4,5,6,7\} \) c'è (almeno) un verde, il $4$ è rosso, il $6$ è giallo e il $5$ non sa il proprio cappello, dunque il settimo è verde indipendentemente dal colore del cappello di $5$.

[Quinzio]

@utente_medio e altri

Ho preso il tuo programma:
https://www.matematicamente.it/forum/vi ... 0#p8688896
Lo ricopio nello spoiler sotto.

    #include <iostream>
    #include <vector>

    using namespace std;

    const unsigned int G = 7;//NUMERO GIOCATORI
    const unsigned int C = 3;//NUMERO COLORI
    const unsigned int M = 3;//MASSIMO OCCORRENZE COLORE
    const char c[C] = {'G', 'R', 'V'};//ELENCO COLORI

    void definisci_alternative_giocatori(vector<unsigned int> *a, const unsigned int *s, const unsigned int g)
    {
        unsigned int o[C] = {};//CONTEGGIO OCCORRENZE COLORI
        for(unsigned int i = 0; i < G; ++o[s[i++]]);
        for(unsigned int i = 0; i < g; ++i)
        {
            for(unsigned int j = 0; j < C; ++j)
            {
                if(j == s[i] || o[j] != M)
                {
                    a[i].push_back(j);
                }
            }
        }
    }

    bool fun(const unsigned int *s, unsigned int *d, const unsigned int g)
    {
        vector<unsigned int> a[G];//ALTERNATIVE GIOCATORI
        definisci_alternative_giocatori(a, s, g);
        for(unsigned int i = 0; i < g; ++i)
        {
            if(i && a[i].size() > 1)
            {
                for(unsigned int j = 0; j < a[i].size(); ++j)
                {
                    if(a[i][j] != s[i])
                    {
                        unsigned int s_ip[G];//SEQUENZA IPOTETICA
                        for(unsigned int k = 0; k < G; s_ip[k] = k == i ? a[i][j] : s[k], ++k);
                        if(!fun(s_ip, d, i))
                        {
                            a[i].erase(a[i].begin() + j--);
                        }
                    }
                }
            }
            if(a[i].size() == 1)
            {
                if(g == G)
                {
                    d[i] = a[i][0];
                }
                else if(d[i] != a[i][0])
                {
                    return false;
                }
            }
            else if(g != G && d[i] != C)
            {
                return false;
            }
        }
        return true;
    }

    int main()
    {
        char str[G + 1] = "VRRRGGV";//INPUT SEQUENZA COLORI GIOCATORI

        unsigned int s[G];//SEQUENZA COLORI GIOCATORI
        unsigned int d[G];//DEDUZIONI GIOCATORI(IL VALORE "C" INDICA "NON SO", VALORI MINORI INDICANO I CORRISPETTIVI ELEMENTI DI "c")
        for(unsigned int i = 0, j; i < G; s[i] = j, d[i++] = C)
        {
            for(j = 0; c[j] != str[i]; ++j);
        }
        fun(s, d, G);
        for(unsigned int i = 0; i < G; ++i)
        {
            cout << "GIOCATORE " << i + 1 << ": " << c[s[i]] << " -> " << (d[i] == C ? '?' : c[d[i]]) << "\n";
        }
    }


Questo l'output:

Codice:
    GIOCATORE 1: V -> ?
    GIOCATORE 2: R -> ?
    GIOCATORE 3: R -> ?
    GIOCATORE 4: R -> R
    GIOCATORE 5: G -> ?
    GIOCATORE 6: G -> G
    GIOCATORE 7: V -> V

    Process returned 0 (0x0)   execution time : 0.013 s

l'ho modificato in modo da processare una dopo l'altra le 24 sequenze che ho postato qui, generate dal mio programma:
https://www.matematicamente.it/forum/vi ... 0#p8688878
Le copio nello spoiler sotto.

   7)  R R G R G G V nasc  V V
   8)  R R V R V G V nasc  G G
  11)  R R G R V G V nasc  G V
  12)  R R V R G G V nasc  V G
  45)  R G R R G G V nasc  V V
  46)  R V R R V G V nasc  G G
  49)  R G R R V G V nasc  G V
  50)  R V R R G G V nasc  V G
  96)  G R R R G G V nasc  V V
  97)  V R R R V G V nasc  G G
 100)  G R R R V G V nasc  G V
 101)  V R R R G G V nasc  V G
 128)  R G V R G G V nasc  R V
 130)  R V G R V G V nasc  R G
 136)  R G V R V G V nasc  R G
 138)  R V G R G G V nasc  R V
 140)  G R V R G G V nasc  R V
 143)  V R G R V G V nasc  R G
 152)  G R V R V G V nasc  G R
 155)  V R G R G G V nasc  V R
 157)  G V R R G G V nasc  V R
 159)  V G R R V G V nasc  G R
 165)  G V R R V G V nasc  G R
 167)  V G R R G G V nasc  V R

il programma modificato e' questo nello spoiler sotto, cosi' da vedere che non ho messo trucchi strani
ci sono 25 stringhe, le prime 24 sono quelle postate da me, poi ce n'e' un'altra di controllo.

#include <iostream>
#include <vector>

using namespace std;

const unsigned int G = 7;//NUMERO GIOCATORI
const unsigned int C = 3;//NUMERO COLORI
const unsigned int M = 3;//MASSIMO OCCORRENZE COLORE
const char c[C] = {'G', 'R', 'V'};//ELENCO COLORI

void definisci_alternative_giocatori(vector<unsigned int> *a, const unsigned int *s, const unsigned int g)
{
    unsigned int o[C] = {};//CONTEGGIO OCCORRENZE COLORI
    for(unsigned int i = 0; i < G; ++o[s[i++]]);
    for(unsigned int i = 0; i < g; ++i)
    {
        for(unsigned int j = 0; j < C; ++j)
        {
            if(j == s[i] || o[j] != M)
            {
                a[i].push_back(j);
            }
        }
    }
}

bool fun(const unsigned int *s, unsigned int *d, const unsigned int g)
{
    vector<unsigned int> a[G];//ALTERNATIVE GIOCATORI
    definisci_alternative_giocatori(a, s, g);
    for(unsigned int i = 0; i < g; ++i)
    {
        if(i && a[i].size() > 1)
        {
            for(unsigned int j = 0; j < a[i].size(); ++j)
            {
                if(a[i][j] != s[i])
                {
                    unsigned int s_ip[G];//SEQUENZA IPOTETICA
                    for(unsigned int k = 0; k < G; s_ip[k] = k == i ? a[i][j] : s[k], ++k);
                    if(!fun(s_ip, d, i))
                    {
                        a[i].erase(a[i].begin() + j--);
                    }
                }
            }
        }
        if(a[i].size() == 1)
        {
            if(g == G)
            {
                d[i] = a[i][0];
            }
            else if(d[i] != a[i][0])
            {
                return false;
            }
        }
        else if(g != G && d[i] != C)
        {
            return false;
        }
    }
    return true;
}

int main()
{
#define N_CASI 25
    char str[N_CASI][G + 1] = {
			"RRGRGGV",
			"RRVRVGV",
			"RRGRVGV",
			"RRVRGGV",
			"RGRRGGV",
			"RVRRVGV",
			"RGRRVGV",
			"RVRRGGV",
			"GRRRGGV",
			"VRRRVGV",
			"GRRRVGV",
			"VRRRGGV",
			"RGVRGGV",
			"RVGRVGV",
			"RGVRVGV",
			"RVGRGGV",
			"GRVRGGV",
			"VRGRVGV",
			"GRVRVGV",
			"VRGRGGV",
			"GVRRGGV",
			"VGRRVGV",
			"GVRRVGV",
			"VGRRGGV",
			"GGVRVGV",
    };

    unsigned int s[G];//SEQUENZA COLORI GIOCATORI
    unsigned int d[G];//DEDUZIONI GIOCATORI(IL VALORE "C" INDICA "NON SO", VALORI MINORI INDICANO I CORRISPETTIVI ELEMENTI DI "c")
    for (int caso = 0; caso < N_CASI; caso++) {
    	cout << endl << endl << "Stringa n.  " << caso << " " << str[caso] << endl;
    	for(unsigned int i = 0, j; i < G; s[i] = j, d[i++] = C)
		{
			for(j = 0; c[j] != str[caso][i]; ++j);
		}
		fun(s, d, G);
		for(unsigned int i = 0; i < G; ++i)
		{
			cout << "GIOCATORE " << i + 1 << ": " << c[s[i]] << " -> " << (d[i] == C ? '?' : c[d[i]]) << "\n";
		}
    }
}

Questo e' l'output del programma:

Stringa n.  0 RRGRGGV
GIOCATORE 1: R -> ?
GIOCATORE 2: R -> ?
GIOCATORE 3: G -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: G -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  1 RRVRVGV
GIOCATORE 1: R -> ?
GIOCATORE 2: R -> ?
GIOCATORE 3: V -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: V -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  2 RRGRVGV
GIOCATORE 1: R -> ?
GIOCATORE 2: R -> ?
GIOCATORE 3: G -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: V -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  3 RRVRGGV
GIOCATORE 1: R -> ?
GIOCATORE 2: R -> ?
GIOCATORE 3: V -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: G -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  4 RGRRGGV
GIOCATORE 1: R -> ?
GIOCATORE 2: G -> ?
GIOCATORE 3: R -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: G -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  5 RVRRVGV
GIOCATORE 1: R -> ?
GIOCATORE 2: V -> ?
GIOCATORE 3: R -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: V -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  6 RGRRVGV
GIOCATORE 1: R -> ?
GIOCATORE 2: G -> ?
GIOCATORE 3: R -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: V -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  7 RVRRGGV
GIOCATORE 1: R -> ?
GIOCATORE 2: V -> ?
GIOCATORE 3: R -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: G -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  8 GRRRGGV
GIOCATORE 1: G -> ?
GIOCATORE 2: R -> ?
GIOCATORE 3: R -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: G -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  9 VRRRVGV
GIOCATORE 1: V -> ?
GIOCATORE 2: R -> ?
GIOCATORE 3: R -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: V -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  10 GRRRVGV
GIOCATORE 1: G -> ?
GIOCATORE 2: R -> ?
GIOCATORE 3: R -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: V -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  11 VRRRGGV
GIOCATORE 1: V -> ?
GIOCATORE 2: R -> ?
GIOCATORE 3: R -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: G -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  12 RGVRGGV
GIOCATORE 1: R -> ?
GIOCATORE 2: G -> ?
GIOCATORE 3: V -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: G -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  13 RVGRVGV
GIOCATORE 1: R -> ?
GIOCATORE 2: V -> ?
GIOCATORE 3: G -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: V -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  14 RGVRVGV
GIOCATORE 1: R -> ?
GIOCATORE 2: G -> ?
GIOCATORE 3: V -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: V -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  15 RVGRGGV
GIOCATORE 1: R -> ?
GIOCATORE 2: V -> ?
GIOCATORE 3: G -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: G -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  16 GRVRGGV
GIOCATORE 1: G -> ?
GIOCATORE 2: R -> ?
GIOCATORE 3: V -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: G -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  17 VRGRVGV
GIOCATORE 1: V -> ?
GIOCATORE 2: R -> ?
GIOCATORE 3: G -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: V -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  18 GRVRVGV
GIOCATORE 1: G -> ?
GIOCATORE 2: R -> ?
GIOCATORE 3: V -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: V -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  19 VRGRGGV
GIOCATORE 1: V -> ?
GIOCATORE 2: R -> ?
GIOCATORE 3: G -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: G -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  20 GVRRGGV
GIOCATORE 1: G -> ?
GIOCATORE 2: V -> ?
GIOCATORE 3: R -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: G -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  21 VGRRVGV
GIOCATORE 1: V -> ?
GIOCATORE 2: G -> ?
GIOCATORE 3: R -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: V -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  22 GVRRVGV
GIOCATORE 1: G -> ?
GIOCATORE 2: V -> ?
GIOCATORE 3: R -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: V -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  23 VGRRGGV
GIOCATORE 1: V -> ?
GIOCATORE 2: G -> ?
GIOCATORE 3: R -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: G -> ?
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V


Stringa n.  24 GGVRVGV
GIOCATORE 1: G -> ?
GIOCATORE 2: G -> ?
GIOCATORE 3: V -> ?
GIOCATORE 4: R -> R
GIOCATORE 5: V -> V
GIOCATORE 6: G -> G
GIOCATORE 7: V -> V

Questo e' l'output in formato compatto, in modo da essere comodo da guardare visivamente

???R?GV
???R?GV
???R?GV
???R?GV
???R?GV
???R?GV
???R?GV
???R?GV
???R?GV
???R?GV
???R?GV
???R?GV
???R?GV
???R?GV
???R?GV
???R?GV
???R?GV
???R?GV
???R?GV
???R?GV
???R?GV
???R?GV
???R?GV
???R?GV


???RVGV

Risultato:
tutte le 24 stringhe da me postate generano correttamente la sequenza:
???R?GV
quella data dal testo del problema.
La 25esima stringa, l'ultima, di controllo, genera una sequenza diversa.
Attenzione: la numerazione delle stringhe va da 0 a 24.

Conclusione:
tutte le 24 stringhe da me generate, passate al controllo con il programma di utente_medio, passano il controllo.
Il programma di utente_medio usa un algoritmo sostanzialmente diverso dal mio, in modo da essere utilizzato come controllo robusto.
Problemi come quello in oggetto sono gia' decisamente complessi e difficili da trattare "a mano" , "a mente" o con teoremi di tipo matematico, in linguaggio naturale.
Queste modalita' sono "error prone".
Solo un algoritmo in forma di software processato da un computer che tratta tutti i casi possibili in modo esaustivo puo' generare risposte piu' affidabili.

Inoltre:
Bisognerebbe controllare che tutte le 1050 stringhe possibili e diverse da quelle postate da me generassero una sequenza di deduzioni diversa da ???R?GV.