[Java] Saltare da un punto a un'altro e arrestare l'esecuzione del codice

[stefandre_nicari]

Devo risolvere un problema un po' complicato. Devo fare 48 controlli if. Il problema è che scrivere 48 if else è scandaloso...posso raggrupparne alcuni in clicli di for, solo che in questo modo non riesco a concatenarli con l'else. Se faccio 48 if else...quando un if è vero tutta la catena di controlli si arresta...esegue l'istruzione legata all'if e va avanti il programma, ma gli if successivi non vengono eseguiti. Se invece di mettere 9 if else, ad esempio metto 3 cicli for, se un if all'interno del for risulta vero, viene eseguito il codice legato all'if e il programma passa al for successivo, o addirittura esegue gli if mancanti all'interno del ciclo..COSA CHE NON DEVE FARE...
Vorrei sapere se esiste un'istruzione per farmare quella serie di istruzioni se un if risulta vero (una specie di break)...e se esiste un'istruzione per saltare in un altro punto del codice nelle stesse condizioni (if vero)..grazie!

[astorcas]

ho paura a suggerirti qualsiasi cosa perché non ho capito molto... mica potresti postare un po' di codice o magari essere più chiaro? :)

[PGI-Bis]

Le strutture sintattiche a disposizione sono i labeled break e continue o la la cascata nello switch. I primi però funzionano solo nei cicli, per la cascata dipende da come gli if devono essere interecciati.

Ad un livello più astratto sembrebbe pane per dei combinatori ma se non hai esperienza in merito probabilmente è più rapido scrivere i 48 if.

[Johnn]

Io ho la sensazione che ci possa essere qualche problema di progettazione. In parte mi è suggerito dal possibile uso dei for. Ma aspettiamo altri elementi.

Per evitare gli if, come già detto c'è lo switch, oppure, se è il caso di utilizzarle, le eccezioni.

[stefandre_nicari]

Questa è la classe. Quello che volevo tentare di fare era di raggruppare le righe e le colonne in cicli di for...
PS scusate se vi ingombro la pagina...


/**
* @author Andrea
*/

public class IA extends Game{

private static final long serialVersionUID = -2190042828523424036L;

public static void playIA(){
//intercetto tris posibili del giocatore
if(matr[0][0]==1 && matr[0][1]==1){ //riga 0
if(matr[0][2]==0){
matr[0][2]=2;
}
} else if(matr[0][1]==1 && matr[0][2]==1) {
if(matr[0][0]==0){
matr[0][0]=2;
}
} else if(matr[0][0]==1 && matr[0][2]==1) {
if(matr[0][1]==0){
matr[0][1]=2;
}
} else if(matr[1][0]==1 && matr[1][1]==1) { //riga 1
if(matr[1][2]==0){
matr[1][2]=2;
}
} else if(matr[1][1]==1 && matr[1][2]==1) {
if(matr[1][0]==0){
matr[1][0]=2;
}
} else if(matr[1][0]==1 && matr[1][2]==1) {
if(matr[1][1]==0){
matr[1][1]=2;
}
} else if(matr[2][0]==1 && matr[2][1]==1) { //riga 2
if(matr[2][2]==0){
matr[2][2]=2;
}
} else if(matr[2][1]==1 && matr[2][2]==1) {
if(matr[2][0]==0){
matr[2][0]=2;
}
} else if(matr[2][0]==1 && matr[2][2]==1) {
if(matr[2][1]==0){
matr[2][1]=2;
}
} else if(matr[0][0]==1 && matr[1][0]==1) { //colonna 0
if(matr[2][0]==0){
matr[2][0]=2;
}
} else if(matr[1][0]==1 && matr[2][0]==1){
if(matr[0][0]==0){
matr[0][0]=2;
}
} else if(matr[0][0]==1 && matr[2][0]==1){
if(matr[1][0]==0){
matr[1][0]=2;
}
} else if(matr[0][1]==1 && matr[1][1]==1){ //colonna 1
if(matr[2][1]==0){
matr[2][1]=2;
}
} else if(matr[1][1]==1 && matr[2][1]==1){
if(matr[0][1]==0){
matr[0][1]=2;
}
} else if(matr[0][1]==1 && matr[2][1]==1){
if(matr[1][1]==0){
matr[1][1]=2;
}
} else if(matr[0][2]==1 && matr[1][2]==1){ //colonna 2
if(matr[2][2]==0){
matr[2][2]=2;
}
} else if(matr[1][2]==1 && matr[2][2]==1){
if(matr[0][2]==0){
matr[0][2]=2;
}
} else if(matr[0][2]==1 && matr[2][2]==1){
if(matr[1][2]==0){
matr[1][2]=2;
}
} else if(matr[0][0]==1 && matr[1][1]==1){ //diagonale 1
if(matr[2][2]==0){
matr[2][2]=2;
}
} else if(matr[1][1]==1 && matr[2][2]==1){
if(matr[0][0]==0){
matr[0][0]=2;
}
} else if(matr[0][0]==1 && matr[2][2]==1){
if(matr[1][1]==0){
matr[1][1]=2;
}
} else if(matr[0][2]==1 && matr[1][1]==1){ //diagonale 2
if(matr[2][0]==0){
matr[2][0]=2;
}
} else if(matr[1][1]==1 && matr[2][0]==1){
if(matr[0][2]==0){
matr[0][2]=2;
}
} else if(matr[0][2]==1 && matr[2][0]==1){
if(matr[1][1]==0){
matr[1][1]=2;
}
} else //tentativo vittoria IA
if(matr[0][0]==2 && matr[0][1]==2){ //riga 0
if(matr[0][2]==0){
matr[0][2]=2;
}
} else if(matr[0][1]==2 && matr[0][2]==2) {
if(matr[0][0]==0){
matr[0][0]=2;
}
} else if(matr[0][0]==2 && matr[0][2]==2) {
if(matr[0][1]==0){
matr[0][1]=2;
}
} else if(matr[1][0]==2 && matr[1][1]==2) { //riga 1
if(matr[1][2]==0){
matr[1][2]=2;
}
} else if(matr[1][1]==2 && matr[1][2]==2) {
if(matr[1][0]==0){
matr[1][0]=2;
}
} else if(matr[1][0]==2 && matr[1][2]==2) {
if(matr[1][1]==0){
matr[1][1]=2;
}
} else if(matr[2][0]==2 && matr[2][1]==2) { //riga 2
if(matr[2][2]==0){
matr[2][2]=2;
}
} else if(matr[2][1]==2 && matr[2][2]==2) {
if(matr[2][0]==0){
matr[2][0]=2;
}
} else if(matr[2][0]==2 && matr[2][2]==2) {
if(matr[2][1]==0){
matr[2][1]=2;
}
} else if(matr[0][0]==2 && matr[1][0]==2) { //colonna 0
if(matr[2][0]==0){
matr[2][0]=2;
}
} else if(matr[1][0]==2 && matr[2][0]==2){
if(matr[0][0]==0){
matr[0][0]=2;
}
} else if(matr[0][0]==2 && matr[2][0]==2){
if(matr[1][0]==0){
matr[1][0]=2;
}
} else if(matr[0][1]==2 && matr[1][1]==2){ //colonna 1
if(matr[2][1]==0){
matr[2][1]=2;
}
} else if(matr[1][1]==2 && matr[2][1]==2){
if(matr[0][1]==0){
matr[0][1]=2;
}
} else if(matr[0][1]==2 && matr[2][1]==2){
if(matr[1][1]==0){
matr[1][1]=2;
}
} else if(matr[0][2]==2 && matr[1][2]==2){ //colonna 2
if(matr[2][2]==0){
matr[2][2]=2;
}
} else if(matr[1][2]==2 && matr[2][2]==2){
if(matr[0][2]==0){
matr[0][2]=2;
}
} else if(matr[0][2]==2 && matr[2][2]==2){
if(matr[1][2]==0){
matr[1][2]=2;
}
} else if(matr[0][0]==2 && matr[1][1]==2){ //diagonale 1
if(matr[2][2]==0){
matr[2][2]=2;
}
} else if(matr[1][1]==2 && matr[2][2]==2){
if(matr[0][0]==0){
matr[0][0]=2;
}
} else if(matr[0][0]==2 && matr[2][2]==2){
if(matr[1][1]==0){
matr[1][1]=2;
}
} else if(matr[0][2]==2 && matr[1][1]==2){ //diagonale 2
if(matr[2][0]==0){
matr[2][0]=2;
}
} else if(matr[1][1]==2 && matr[2][0]==2){
if(matr[0][2]==0){
matr[0][2]=2;
}
} else if(matr[0][2]==2 && matr[2][0]==2){
if(matr[1][1]==0){
matr[1][1]=2;
}
} else {
//giocata casuale con controllo casella occupata
int rand1=0;
int rand2=0;
do{
rand1=(int)(Math.random()*3);
rand2=(int)(Math.random()*3);
if (matr[rand1][rand2]==0){
matr[rand1][rand2]=2;
}
} while (matr[rand1][rand2]!=0);
//sto do while mi fa bloccare il brogramma..da correggere
}
}
}

[Gelert]

se ho capito bene quel codice è una serie di "else if"

cioè: hai una matrice in cui devi testare alcune cose, nel momento in cui ne trovi una che è vera esegui qualcosa ed esci senza dover eseguire gli ulteriori controlli

il codice appropriato è questo:


for (condizione del for){
if (condizione if){
quello che devi fare;
break;
}
}


l'istruzione break, quando viene eseguita, ti fa uscire dal for (o da un while) anche se non si è verificata la condizione di uscita del for

l'istruzione break si associa all'istruzione continue che fa uscire solo dall'iterazione corrente del for (o del while) e passa alla successiva iterazione senza svolgere il resto del codice

nel codice che ti ho scritto lui continuerà ad eseguire il for finchè non diventa falsa la condizione del for oppure finchè non esegue l'istruzione break, siccome l'istruzione break è dentro l'if alla prima esecuzione dell'if terminerà l'esecuzione del for e andrà al codice successivo al for

[bobbytre]

Devo risolvere un problema un po' complicato. Devo fare 48 controlli if. Il problema è che scrivere 48 if else è scandaloso...posso raggrupparne alcuni in clicli di for, solo che in questo modo non riesco a concatenarli con l'else. Se faccio 48 if else...quando un if è vero tutta la catena di controlli si arresta...esegue l'istruzione legata all'if e va avanti il programma, ma gli if successivi non vengono eseguiti. Se invece di mettere 9 if else, ad esempio metto 3 cicli for, se un if all'interno del for risulta vero, viene eseguito il codice legato all'if e il programma passa al for successivo, o addirittura esegue gli if mancanti all'interno del ciclo..COSA CHE NON DEVE FARE...
Vorrei sapere se esiste un'istruzione per farmare quella serie di istruzioni se un if risulta vero (una specie di break)...e se esiste un'istruzione per saltare in un altro punto del codice nelle stesse condizioni (if vero)..grazie!

Puoi provare cosi:

int stop_a = true;
int stop_b = true;

for( ... )
{
if(stop_a == false)break;
for( ... )
{
if(stop_b == false)break;
for( ... )
{
if( CONDIZIONE_DA_VERIFICARE )
{
// TROVATO !!!
stop_a = false;
stop_b = false;
break;
}
}
}
}

[wingman87]

Se dopo l'assegnazione che fai all'interno dell'if non devi fare altro all'interno del metodo puoi direttamente ritornare al metodo chiamante con return.

[banryu79]

[OT]

Ad un livello più astratto sembrebbe pane per dei combinatori... [cutted]
Che cosa sono? Dove posso documentarmi?

[PGI-Bis]

[OT]

Che cosa sono? Dove posso documentarmi?

Cerca "parser combinators".

[gugoXX]

Io applicherei le regole 3 e 4 della buona programmazione (Unix Philosophy)


Rule 4. Fancy algorithms are buggier than simple ones, and they're much harder to implement. Use simple algorithms as well as simple data structures.

Rule 5. Data dominates. If you've chosen the right data structures and organized things well, the algorithms will almost always be self-evident. Data structures, not algorithms, are central to programming.[9]

E propongo la seguente, appunto, nello stile di avere una solida e semplice base dati, allo scopo di avere algoritmi brevi, semplici e leggibili


La struttura TrisChecker contiene le 2 coordinate per cui occorre controllare 1, la coordinata per cui occorre controllare 0 ed eventualmente settare il 2

class Program
{
private static readonly TrisChecker[] trisChecker =
new[]{
new TrisChecker(){Chk11=new Point(0,0), Chk12=new Point(0,1), Chk0=new Point(1,0)},
new TrisChecker(){Chk11=new Point(0,1), Chk12=new Point(0,2), Chk0=new Point(0,0)},
new TrisChecker(){Chk11=new Point(1,0), Chk12=new Point(1,1), Chk0=new Point(1,2)},
};

static void Main(string[] args)
{
int[,] matr = new int[3,3];

bool fnd = false;
foreach (var chk in trisChecker)
{
if (chk.Found(matr, 0))
{
fnd = true;
break;
}
}

if (fnd == false)
{
foreach (var chk in trisChecker)
{
if (chk.Found(matr, 0))
{
fnd = true;
break;
}
}
}

if (fnd == false)
{
//casuale
}


//Oppure in sintassi Funzionale C#
var result = trisChecker.FirstOrDefault(chk => chk.Found(matr, 0));
if (result == null)
result = trisChecker.FirstOrDefault(chk => chk.Found(matr, 1));
if (result==null)
{
//casuale
}
}

public class TrisChecker
{
public Point Chk11;
public Point Chk12;
public Point Chk0;

public bool Check(int[,] matr, int val)
{
bool ret = false;
if (matr[Chk11.X, Chk11.Y] == val &&
matr[Chk12.X, Chk12.Y] == val)
{
if (matr[Chk0.X, Chk0.Y] == 0)
matr[Chk0.X, Chk0.Y] = 2;
ret=true;
}
return ret;
}
}

public class Point
{
public int X;
public int Y;

public Point(int x,int y)
{
X=x;
Y=y;
}
}
}

[PGI-Bis]

Preferisco i 48 If.

[gugoXX]

Preferisco i 48 If.

Si', ma scrivici anche i test pero'.
48 If hanno una complessita' ciclomatica da fare spavento.

[PGI-Bis]

Io non testo per filosofia.

La mia preferenza è d'acchitto. Non so perchè ma c'è qualcosa nella regolarità di quegli if che è attraente. Una colossale rottura di scatole da scrivere ma ha un suo senso estetico.

In più l'if-else è un mattone talmente basilare che solo guardandolo anche un novizio capirebbe: qui si stanno prendendo delle decisioni.

Ci vorrebbe una soluzione che mantenga questa familiarità e una regolarità strutturale, nel caso in cui siano necessari più passaggi.

[PGI-Bis]

Per la cronaca son rimasto sveglio fino adesso per scrivere 'sta cagata:

List<EXPR<?>> LIST = new LinkedList<EXPR<?>>();
LIST.add(IF(M00.EQUALS(1).AND(M01.EQUALS(1))).THEN(IF(M02.EQUALS(0)).THEN(M02.ASSIGN(2))));
LIST.add(IF(M01.EQUALS(1).AND(M02.EQUALS(1))).THEN(IF(M00.EQUALS(0)).THEN(M00.ASSIGN(2))));

//...'NA QUARANTINA A SEGUIRE...

for(EXPR<?> E : LIST) if(E.get() != null) break;

MXY sono dei Cell.

:coffee:

E' un DSL, definito in:

class DSL {
static IF IF(VALUE<BOOLEAN> condition) { return new IF(condition); }
static CELL CELL(int[][] data, int i, int j) { return new CELL(data, i, j); }
static EXPR<?> CHECK(CELL C0, CELL C1, int VALUE1, CELL CR, int VALUE2, int RESULT) {
return IF(C0.EQUALS(VALUE1).AND(C1.EQUALS(VALUE1))).THEN(IF(CR.EQUALS(VALUE2)).THEN(CR.ASSIGN(RESULT)));
}
}

interface VALUE<T> {

T get();
}

interface VARIABLE<T> extends EXPR<T> {

void set(T value);
}

class VOID<T> implements EXPR<T> {

public T get() {
return null;
}
}

class IF implements EXPR<BOOLEAN> {
private BOOLEAN condition;

IF(VALUE<BOOLEAN> condition) {
this.condition = condition.get();
}

public <T> EXPR<T> THEN(EXPR<T> e) {
if(condition == BOOLEAN.TRUE) {
return e;
} else {
return new VOID<T>();
}
}

public BOOLEAN get() {
return null;
}
}

interface EXPR<T> extends VALUE<T> {
}

class BOOLEAN implements VALUE<BOOLEAN> {
static BOOLEAN TRUE = new BOOLEAN();
static BOOLEAN FALSE = new BOOLEAN();

BOOLEAN AND(VALUE<BOOLEAN> that) {
return this == TRUE && that.get() == TRUE ? TRUE : FALSE;
}

public BOOLEAN get() {
return this;
}
}

class CELL implements VARIABLE<Integer> {
int[][] data;
int i, j;
CELL(int[][] data, int i, int j) {
this.data = data;
this.i = i;
this.j = j;
}

BOOLEAN EQUALS(int value) {
return data[i][j] == value ? BOOLEAN.TRUE : BOOLEAN.FALSE;
}

ASSIGN<Integer> ASSIGN(int value) {
return new ASSIGN<Integer>(this, value);
}

public void set(Integer value) {
data[i][j] = value;
}

public Integer get() {
return data[i][j];
}
}

class ASSIGN<T> implements EXPR<T> {
private T value;
private VARIABLE<T> variable;

ASSIGN(VARIABLE<T> var, T value) {
this.variable = var;
this.value = value;
}

public T get() {
variable.set(value);
return value;
}
}

Utilità -52.000 ma mi sono divertito come una faina :D.