|
|||||||
|
|
|
![]() |
|
|
Strumenti |
|
|
#1 | ||||||
|
Senior Member
Iscritto dal: Feb 2007
Città: Verona
Messaggi: 1060
|
[C#] Risiko
![]() Salve a tutti, scrivo questa volta non per chiedere un aiuto ma per condividere il risultato di un mio studio. Sono un appassionato di Risiko e, conseguentemente, anche di rosiko Per il primo appuntamento, ho pensato di studiare che relazione fortunosa esiste tra attaccante e difensore. Per chi non lo sapesse, la sessione di attacco nel Risiko si svolge con le seguenti regole: - L'attaccante dichiara da quale stato di sua "proprietà" attacca quale stato altrui Quote:
Quote:
- L'attaccante tira i dadi - Il difensore tira anch'egli i dadi - Il dado con il valore più alto dell'attaccante viene confrontato con il dado con il valore più grande del difensore. - Il confronto avviene così (A e D sono rispettivamente il valore del dado dell'attaccante e del difensore confrontati): A > D allora vince A A <= D allora vince D Quote:
Quote:
Mi spiego meglio, con termini matematici: voglio trovare Quote:
Siccome risulta più vantaggioso tirare sempre 3 dadi, e siccome questo è il caso più comune, ipotizzo che l'attaccante tiri 3 dadi e che il difensore faccia lo stesso. Per ogni possibile risultato dei due lanci valuto il numero di armate perse da ciascuna parte e lo sommo, per poi calcolare finalmente il rapporto D/A. Bisogna cominciare a studiare i dadi. 3 dadi tirati contemporaneamente generano delle terzine rappresentabili da COMBINAZIONI RIPETUTE DI ORDINE 6 E CLASSE 3 Queste sono tutte le possibili combinazioni di valori ottenute dal tiro di 3 dadi: Codice:
[1, 1, 1] - 1 [1, 1, 2] - 3 [1, 1, 3] - 3 [1, 1, 4] - 3 [1, 1, 5] - 3 [1, 1, 6] - 3 [1, 2, 2] - 3 [1, 2, 3] - 6 [1, 2, 4] - 6 [1, 2, 5] - 6 [1, 2, 6] - 6 [1, 3, 3] - 3 [1, 3, 4] - 6 [1, 3, 5] - 6 [1, 3, 6] - 6 [1, 4, 4] - 3 [1, 4, 5] - 6 [1, 4, 6] - 6 [1, 5, 5] - 3 [1, 5, 6] - 6 [1, 6, 6] - 3 [2, 2, 2] - 1 [2, 2, 3] - 3 [2, 2, 4] - 3 [2, 2, 5] - 3 [2, 2, 6] - 3 [2, 3, 3] - 3 [2, 3, 4] - 6 [2, 3, 5] - 6 [2, 3, 6] - 6 [2, 4, 4] - 3 [2, 4, 5] - 6 [2, 4, 6] - 6 [2, 5, 5] - 3 [2, 5, 6] - 6 [2, 6, 6] - 3 [3, 3, 3] - 1 [3, 3, 4] - 3 [3, 3, 5] - 3 [3, 3, 6] - 3 [3, 4, 4] - 3 [3, 4, 5] - 6 [3, 4, 6] - 6 [3, 5, 5] - 3 [3, 5, 6] - 6 [3, 6, 6] - 3 [4, 4, 4] - 1 [4, 4, 5] - 3 [4, 4, 6] - 3 [4, 5, 5] - 3 [4, 5, 6] - 6 [4, 6, 6] - 3 [5, 5, 5] - 1 [5, 5, 6] - 3 [5, 6, 6] - 3 [6, 6, 6] - 1 Il numero dopo il trattino è la probabilità associata, su 216 (6³), che sono le disposizioni ripetute di ordine 6 e classe 3. E' in definitiva il numero di permutazioni possibili per quella terzina, ottenuto così: Quote:
Bando alle ciance, questo è il codice. Non è il massimo dell'efficienza, visto che non presenta nessuna ottimizzazione. Ho appena iniziato ad usare il C#, quindi perdonatemi errori madornali. Codice:
using System;
using System.Collections.Generic;
namespace Risiko {
class Risiko {
static void Main ( string[] args )
{
List<Terzina> lanci = combinazioniDadi( );
uint[][][] esiti = new uint[lanci.Count][][];
for ( int i = 0 ; i < esiti.Length ; i++ ) {
esiti[i] = new uint[lanci.Count][];
for ( int j = 0 ; j < esiti[i].Length ; j++ ) {
esiti[i][j] = new uint[2];
}
}
for ( int i = 0 ; i < esiti.Length ; i++ ) {
for ( int j = 0 ; j < esiti[i].Length ; j++ ) {
esiti[i][j][0] = lanci[i].abbatteDifesa( lanci[j] );
esiti[i][j][1] = lanci[i].permutazioni * lanci[j].permutazioni;
}
}
ulong pAttacco = 0, pDifesa = 0;
for ( int i = 0 ; i < esiti.Length ; i++ ) {
for ( int j = 0 ; j < esiti[i].Length ; j++ ) {
pAttacco += (ulong)( esiti[i][j][0] * esiti[i][j][1] );
pDifesa += (ulong)( ( 3 - esiti[i][j][0] ) * esiti[i][j][1] );
}
}
double rapporto = (double)pAttacco / pDifesa;
System.Console.WriteLine( "{0} / {1}", pAttacco, pDifesa );
System.Console.WriteLine( rapporto );
System.Console.ReadLine( );
}
public static List<Terzina> combinazioniDadi ( )
{
List<Terzina> l = new List<Terzina>( );
for ( uint a = 1 ; a <= 6 ; a++ ) {
for ( uint b = a ; b <= 6 ; b++ ) {
for ( uint c = b ; c <= 6 ; c++ ) {
l.Add( new Terzina( a, b, c));
}
}
}
return l;
}
}
class Terzina {
public uint a;
public uint b;
public uint c;
public uint permutazioni
{
get
{
return calcPermutazioni( );
}
}
public Terzina ( uint a, uint b, uint c )
{
if ( a <= b && b <= c ) {
this.a = a;
this.b = b;
this.c = c;
} else {
throw new Exception( );
}
}
public uint abbatteDifesa ( Terzina dif )
{
uint k = 0;
if ( this.a > dif.a ) k++;
if ( this.b > dif.b ) k++;
if ( this.c > dif.c ) k++;
return k;
}
public uint abbatteAttacco ( Terzina att )
{
uint k = 0;
if ( this.a >= att.a ) k++;
if ( this.b >= att.b ) k++;
if ( this.c >= att.c ) k++;
return k;
}
private uint calcPermutazioni ( )
{
if ( a == b && a == c )
return 1;
else if ( a == b || a == c || c == b )
return 3;
else
return 6;
}
}
}
Codice:
51642 / 88326 0,584674954147137 in una sessione di attacco prolugata, il numero di armate perse dall'attaccante si avvicina sempre più a 1,71 (il reciproco di 0.5846) volte le armate perse dal difensore. Insomma, conviene giocare in difesa Sono apprezzati consigli, critiche, eccetera
__________________
|
||||||
|
|
|
|
|
#2 | |
|
Senior Member
Iscritto dal: Jul 2009
Messaggi: 1161
|
Quote:
da bambino risiko mi piaceva molto poi ho giocato un po' su internet in partite da 6 persone e mi son accorto che è un gioco abbastanza "stupido", fondamentalmente accade che tutti giocano in difesa cercando di aumentare le proprie truppe sui territori di frontiera, poi arriva il "kamikaze" di turno: DI solito il giocatore che è messo peggio e che non avendo speranze usa tutta le sue truppe contro qualche "vicino" in un attacco che annienta entrambi e quindi gli altri 4 possono di nuovo espandersi, poi nuovamente tutti stanno sulla difensiva e chi è messo peggio e sa che comunque perderà tenta altro attacco disperato e l'altro sfortunato giocatore scelto viene penalizzato. e così via..
__________________
Web2.0 Guides And Tutorials SLR: Canon 6D ZOOM: Canon EF 24-105mm f/4L IS USM FISSI: - Canon EF 28mm f/1.8 USM - Canon EF 40mm f/2.8 STM - Canon EF 50mm f/1.4 USM - Canon EF 100mm f/2 USM - Canon EF 200mm f/2.8L USM II ALTRO: Canon 430 EX II |
|
|
|
|
|
|
#3 |
|
Senior Member
Iscritto dal: Oct 2007
Città: Padova
Messaggi: 4131
|
Ho sempre preferito il futuRisiKo!
__________________
As long as you are basically literate in programming, you should be able to express any logical relationship you understand. If you don’t understand a logical relationship, you can use the attempt to program it as a means to learn about it. (Chris Crawford) |
|
|
|
|
|
#4 |
|
Senior Member
Iscritto dal: Feb 2007
Città: Verona
Messaggi: 1060
|
Io ho sempre e solo giocato al classico
__________________
|
|
|
|
|
|
#5 | |
|
Senior Member
Iscritto dal: Feb 2007
Città: Verona
Messaggi: 1060
|
Quote:
A me danno fastidio quelli che giocano solo sulla difensiva, lasciando armate un po' qui un po' là invece di puntare su confini solidi nel tentativo di ammortizzare i danni. Io sono uno invece che si butta, e il 90% delle volte non ho abbastanza fortuna per fare quello che voglio fare, per cui finisco con l'auto-abbattermi (tipico, il kamikaze di prima Però, ignorando il fatto che ci sono tanti fattori che portano alla sconfitta o alla vittoria, il Risiko si presta abbastanza bene a considerazioni logiche/probabilistiche, che regolarmente si rivelano (quasi) inutili A questo punto potrei fare un'azione commerciale di questo genere: Avete presente il SuperPI, il programma usato per benchare che calcola un certo numero di cifre del pigreco? Potrei fare come quelli che l'hanno scritto e mettermi a vendere le cifre della "costante del Risiko" ![]() Qualche offerente?
__________________
|
|
|
|
|
|
|
#6 | |
|
Senior Member
Iscritto dal: Feb 2003
Città: Stockholm (SE)
Messaggi: 1343
|
Quote:
|
|
|
|
|
|
|
#7 | |
|
Senior Member
Iscritto dal: Feb 2007
Città: Verona
Messaggi: 1060
|
Quote:
Vabbè
__________________
|
|
|
|
|
|
| Strumenti | |
|
|
Tutti gli orari sono GMT +1. Ora sono le: 14:23.













(tipico, il kamikaze di prima








