file_id
stringlengths 4
10
| content
stringlengths 91
42.8k
| repo
stringlengths 7
108
| path
stringlengths 7
251
| token_length
int64 34
8.19k
| original_comment
stringlengths 11
11.5k
| comment_type
stringclasses 2
values | detected_lang
stringclasses 1
value | prompt
stringlengths 34
42.8k
|
|---|---|---|---|---|---|---|---|---|
1668_4 | package Machiavelli.Models;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Serializable;
import java.rmi.RemoteException;
import java.util.ArrayList;
import Machiavelli.Interfaces.Observers.SpelregelsObserver;
import Machiavelli.Interfaces.Remotes.SpelregelsRemote;
/**
* @author Jamie Kalloe
* De spelregels van Machiavelli zijn opgeslagen in een textdocument, deze
* kunnen op elk moment in het spel aangeroepen worden.
*/
public class Spelregels implements SpelregelsRemote, Serializable {
private ArrayList<SpelregelsObserver> observers = new ArrayList<>();
/**
* Retourneerd de spelregels die zijn opgehaald uit de text file.
*
* @return spelregels String
*/
public String getSpelregels() {
try {
return this.getSpelregelsFromResource("spelregels.txt");
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* Deze method haalt de spelregels uit een textfile van het opgegeven pad.
*
* @param fileName naam de van de file waar de spelregels in staan.
*/
private String getSpelregelsFromResource(String fileName) throws Exception {
String text = null;
InputStream in = getClass().getResourceAsStream("/Machiavelli/Resources/" + fileName);
BufferedReader input = new BufferedReader(new InputStreamReader(in));
try {
StringBuilder builder = new StringBuilder();
String aux = "";
while ((aux = input.readLine()) != null) {
builder.append(aux + System.getProperty("line.separator"));
}
text = builder.toString();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
input.close();
return text;
}
/**
* Voert de SpelregelsObserver toe aan de lijst met observers.
*/
public void addObserver(SpelregelsObserver observer) throws RemoteException {
observers.add(observer);
}
/**
* Vertelt de observers dat het model is veranderd.
*/
public void notifyObservers() throws RemoteException {
for (SpelregelsObserver observer : observers) {
observer.modelChanged(this);
}
}
}
| Badmuts/Machiavelli | src/Machiavelli/Models/Spelregels.java | 572 | /**
* Vertelt de observers dat het model is veranderd.
*/ | block_comment | nl | package Machiavelli.Models;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Serializable;
import java.rmi.RemoteException;
import java.util.ArrayList;
import Machiavelli.Interfaces.Observers.SpelregelsObserver;
import Machiavelli.Interfaces.Remotes.SpelregelsRemote;
/**
* @author Jamie Kalloe
* De spelregels van Machiavelli zijn opgeslagen in een textdocument, deze
* kunnen op elk moment in het spel aangeroepen worden.
*/
public class Spelregels implements SpelregelsRemote, Serializable {
private ArrayList<SpelregelsObserver> observers = new ArrayList<>();
/**
* Retourneerd de spelregels die zijn opgehaald uit de text file.
*
* @return spelregels String
*/
public String getSpelregels() {
try {
return this.getSpelregelsFromResource("spelregels.txt");
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* Deze method haalt de spelregels uit een textfile van het opgegeven pad.
*
* @param fileName naam de van de file waar de spelregels in staan.
*/
private String getSpelregelsFromResource(String fileName) throws Exception {
String text = null;
InputStream in = getClass().getResourceAsStream("/Machiavelli/Resources/" + fileName);
BufferedReader input = new BufferedReader(new InputStreamReader(in));
try {
StringBuilder builder = new StringBuilder();
String aux = "";
while ((aux = input.readLine()) != null) {
builder.append(aux + System.getProperty("line.separator"));
}
text = builder.toString();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
input.close();
return text;
}
/**
* Voert de SpelregelsObserver toe aan de lijst met observers.
*/
public void addObserver(SpelregelsObserver observer) throws RemoteException {
observers.add(observer);
}
/**
* Vertelt de observers<SUF>*/
public void notifyObservers() throws RemoteException {
for (SpelregelsObserver observer : observers) {
observer.modelChanged(this);
}
}
}
|
1670_0 | // Mensen met meer verstand van java zijn zeer welkom, om de code te verbeteren.
package com.transistorsoft.cordova.backgroundfetch;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.IOException;
import java.net.Socket;
import org.json.*;
import org.json.JSONObject;
import org.json.JSONArray;
import java.lang.Object;
import android.content.SharedPreferences;
import com.transistorsoft.tsbackgroundfetch.BackgroundFetch;
import com.transistorsoft.tsbackgroundfetch.BGTask;
import android.util.Log;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import androidx.core.app.NotificationCompat;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.app.PendingIntent;
import app.netlob.magiscore.R;
public class BackgroundFetchHeadlessTask implements HeadlessTask {
@Override
public void onFetch(Context context, BGTask task) {
String taskId = task.getTaskId();
boolean isTimeout = task.getTimedOut();
if (isTimeout) {
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask TIMEOUT: " + taskId);
BackgroundFetch.getInstance(context).finish(taskId);
return;
}
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask: onFetch: " + taskId);
// Perform your work here....
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
SharedPreferences SharedPrefs = context.getSharedPreferences("Gemairo", 0);
String Bearer = SharedPrefs.getString("Tokens", "");
String SchoolURL = SharedPrefs.getString("SchoolURL", "");
String PersonID = SharedPrefs.getString("PersonID", "");
String latestgrades = SharedPrefs.getString("latestGrades", "");
try {
if (latestgrades == "" || PersonID == "" || SchoolURL == "" || Bearer =="") return;
JSONObject Tokens = new JSONObject(Bearer);
final JSONObject latestGrades = new JSONObject(latestgrades);
String CompleteURL = "https://" + SchoolURL.replaceAll("\"", "") + "/api/personen/" + PersonID
+ "/cijfers/laatste?top=50&skip=0";
try {
// Refresh token
URL tokenurl = new URL("https://accounts.magister.net/connect/token");
StringBuffer tokencontent = new StringBuffer();
HttpURLConnection tokencon = (HttpURLConnection) tokenurl.openConnection();
tokencon.setRequestMethod("POST");
tokencon.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
// tokencon.setRequestProperty("Authorization", "Bearer " +
// Tokens.getString("access_token"));
tokencon.setRequestProperty("cache-control", "no-cache");
tokencon.setRequestProperty("x-requested-with", "app.netlob.magiscore");
tokencon.setDoOutput(true);
String body = "refresh_token="+Tokens.getString("refresh_token")+"&client_id=M6LOAPP&grant_type=refresh_token";
byte[] outputInBytes = body.getBytes("UTF-8");
OutputStream os = tokencon.getOutputStream();
os.write(outputInBytes);
os.close();
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(tokencon.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
tokencontent.append(line);
}
}
String tokenresult = tokencontent.toString();
final JSONObject tokenjsonresult = new JSONObject(tokenresult);
//Oplaan van de laatste tokens
SharedPreferences.Editor editor = SharedPrefs.edit();
final JSONObject gemairotokens = new JSONObject();
gemairotokens.put("access_token", tokenjsonresult.getString("access_token"));
gemairotokens.put("id_token", tokenjsonresult.getString("id_token"));
gemairotokens.put("refresh_token", tokenjsonresult.getString("refresh_token"));
editor.putString("Tokens", gemairotokens.toString());
editor.apply();
// Ophalen van de cijfers
URL url = new URL(CompleteURL);
StringBuffer content = new StringBuffer();
HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("GET");
con.setRequestProperty("Content-Type", "application/json");
con.setRequestProperty("Authorization", "Bearer " + tokenjsonresult.getString("access_token"));
con.setRequestProperty("noCache", java.time.Clock.systemUTC().instant().toString());
con.setRequestProperty("x-requested-with", "app.netlob.magiscore");
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(con.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
content.append(line);
}
}
String result = content.toString();
final JSONObject jsonresult = new JSONObject(result);
JSONArray latestGradesItems = (JSONArray) latestGrades.get("items");
Log.d(BackgroundFetch.TAG, latestGradesItems.length() + " - Are latestgrade object's the same? "
+ jsonresult.getString("items").equals(latestGrades.getString("items")));
if (latestGradesItems.length() != 0 && !jsonresult.getString("items").equals(latestGrades.getString("items"))) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
// Als de twee objecten niet hetzelfde zijn stuurt hij een notificatie.
NotificationManager mNotificationManager;
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context.getApplicationContext(),
"Gemairo");
Intent ii = new Intent(context.getPackageManager().getLaunchIntentForPackage("app.netlob.magiscore"));
PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, ii,
PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.BigTextStyle bigText = new NotificationCompat.BigTextStyle();
bigText.bigText("Nieuwe cijfer(s) beschikbaar");
bigText.setBigContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentIntent(pendingIntent);
mBuilder.setSmallIcon(R.drawable.notification);
mBuilder.setContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentText("Nieuwe cijfer(s) beschikbaar");
mBuilder.setPriority(Notification.PRIORITY_HIGH);
mBuilder.setStyle(bigText);
mBuilder.setAutoCancel(true);
mBuilder.setOnlyAlertOnce(true);
mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
String channelId = "Gemairo-Cijfers";
NotificationChannel channel = new NotificationChannel(
channelId,
"Cijfers",
NotificationManager.IMPORTANCE_DEFAULT);
mNotificationManager.createNotificationChannel(channel);
mBuilder.setChannelId(channelId);
}
mNotificationManager.notify(0, mBuilder.build());
} else if (latestGradesItems.length() == 0) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
}
BackgroundFetch.getInstance(context).finish(taskId);
} catch (Exception ex) {
ex.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(ex));
BackgroundFetch.getInstance(context).finish(taskId);
}
} catch (JSONException e) {
e.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(e));
BackgroundFetch.getInstance(context).finish(taskId);
}
}
});
thread.start();
BackgroundFetch.getInstance(context).finish(taskId);
}
} | netlob/magiscore | app/Magiscore/BackgroundFetchHeadlessTask.java | 2,040 | // Mensen met meer verstand van java zijn zeer welkom, om de code te verbeteren. | line_comment | nl | // Mensen met<SUF>
package com.transistorsoft.cordova.backgroundfetch;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.IOException;
import java.net.Socket;
import org.json.*;
import org.json.JSONObject;
import org.json.JSONArray;
import java.lang.Object;
import android.content.SharedPreferences;
import com.transistorsoft.tsbackgroundfetch.BackgroundFetch;
import com.transistorsoft.tsbackgroundfetch.BGTask;
import android.util.Log;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import androidx.core.app.NotificationCompat;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.app.PendingIntent;
import app.netlob.magiscore.R;
public class BackgroundFetchHeadlessTask implements HeadlessTask {
@Override
public void onFetch(Context context, BGTask task) {
String taskId = task.getTaskId();
boolean isTimeout = task.getTimedOut();
if (isTimeout) {
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask TIMEOUT: " + taskId);
BackgroundFetch.getInstance(context).finish(taskId);
return;
}
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask: onFetch: " + taskId);
// Perform your work here....
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
SharedPreferences SharedPrefs = context.getSharedPreferences("Gemairo", 0);
String Bearer = SharedPrefs.getString("Tokens", "");
String SchoolURL = SharedPrefs.getString("SchoolURL", "");
String PersonID = SharedPrefs.getString("PersonID", "");
String latestgrades = SharedPrefs.getString("latestGrades", "");
try {
if (latestgrades == "" || PersonID == "" || SchoolURL == "" || Bearer =="") return;
JSONObject Tokens = new JSONObject(Bearer);
final JSONObject latestGrades = new JSONObject(latestgrades);
String CompleteURL = "https://" + SchoolURL.replaceAll("\"", "") + "/api/personen/" + PersonID
+ "/cijfers/laatste?top=50&skip=0";
try {
// Refresh token
URL tokenurl = new URL("https://accounts.magister.net/connect/token");
StringBuffer tokencontent = new StringBuffer();
HttpURLConnection tokencon = (HttpURLConnection) tokenurl.openConnection();
tokencon.setRequestMethod("POST");
tokencon.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
// tokencon.setRequestProperty("Authorization", "Bearer " +
// Tokens.getString("access_token"));
tokencon.setRequestProperty("cache-control", "no-cache");
tokencon.setRequestProperty("x-requested-with", "app.netlob.magiscore");
tokencon.setDoOutput(true);
String body = "refresh_token="+Tokens.getString("refresh_token")+"&client_id=M6LOAPP&grant_type=refresh_token";
byte[] outputInBytes = body.getBytes("UTF-8");
OutputStream os = tokencon.getOutputStream();
os.write(outputInBytes);
os.close();
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(tokencon.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
tokencontent.append(line);
}
}
String tokenresult = tokencontent.toString();
final JSONObject tokenjsonresult = new JSONObject(tokenresult);
//Oplaan van de laatste tokens
SharedPreferences.Editor editor = SharedPrefs.edit();
final JSONObject gemairotokens = new JSONObject();
gemairotokens.put("access_token", tokenjsonresult.getString("access_token"));
gemairotokens.put("id_token", tokenjsonresult.getString("id_token"));
gemairotokens.put("refresh_token", tokenjsonresult.getString("refresh_token"));
editor.putString("Tokens", gemairotokens.toString());
editor.apply();
// Ophalen van de cijfers
URL url = new URL(CompleteURL);
StringBuffer content = new StringBuffer();
HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("GET");
con.setRequestProperty("Content-Type", "application/json");
con.setRequestProperty("Authorization", "Bearer " + tokenjsonresult.getString("access_token"));
con.setRequestProperty("noCache", java.time.Clock.systemUTC().instant().toString());
con.setRequestProperty("x-requested-with", "app.netlob.magiscore");
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(con.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
content.append(line);
}
}
String result = content.toString();
final JSONObject jsonresult = new JSONObject(result);
JSONArray latestGradesItems = (JSONArray) latestGrades.get("items");
Log.d(BackgroundFetch.TAG, latestGradesItems.length() + " - Are latestgrade object's the same? "
+ jsonresult.getString("items").equals(latestGrades.getString("items")));
if (latestGradesItems.length() != 0 && !jsonresult.getString("items").equals(latestGrades.getString("items"))) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
// Als de twee objecten niet hetzelfde zijn stuurt hij een notificatie.
NotificationManager mNotificationManager;
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context.getApplicationContext(),
"Gemairo");
Intent ii = new Intent(context.getPackageManager().getLaunchIntentForPackage("app.netlob.magiscore"));
PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, ii,
PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.BigTextStyle bigText = new NotificationCompat.BigTextStyle();
bigText.bigText("Nieuwe cijfer(s) beschikbaar");
bigText.setBigContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentIntent(pendingIntent);
mBuilder.setSmallIcon(R.drawable.notification);
mBuilder.setContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentText("Nieuwe cijfer(s) beschikbaar");
mBuilder.setPriority(Notification.PRIORITY_HIGH);
mBuilder.setStyle(bigText);
mBuilder.setAutoCancel(true);
mBuilder.setOnlyAlertOnce(true);
mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
String channelId = "Gemairo-Cijfers";
NotificationChannel channel = new NotificationChannel(
channelId,
"Cijfers",
NotificationManager.IMPORTANCE_DEFAULT);
mNotificationManager.createNotificationChannel(channel);
mBuilder.setChannelId(channelId);
}
mNotificationManager.notify(0, mBuilder.build());
} else if (latestGradesItems.length() == 0) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
}
BackgroundFetch.getInstance(context).finish(taskId);
} catch (Exception ex) {
ex.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(ex));
BackgroundFetch.getInstance(context).finish(taskId);
}
} catch (JSONException e) {
e.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(e));
BackgroundFetch.getInstance(context).finish(taskId);
}
}
});
thread.start();
BackgroundFetch.getInstance(context).finish(taskId);
}
} |
1670_4 | // Mensen met meer verstand van java zijn zeer welkom, om de code te verbeteren.
package com.transistorsoft.cordova.backgroundfetch;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.IOException;
import java.net.Socket;
import org.json.*;
import org.json.JSONObject;
import org.json.JSONArray;
import java.lang.Object;
import android.content.SharedPreferences;
import com.transistorsoft.tsbackgroundfetch.BackgroundFetch;
import com.transistorsoft.tsbackgroundfetch.BGTask;
import android.util.Log;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import androidx.core.app.NotificationCompat;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.app.PendingIntent;
import app.netlob.magiscore.R;
public class BackgroundFetchHeadlessTask implements HeadlessTask {
@Override
public void onFetch(Context context, BGTask task) {
String taskId = task.getTaskId();
boolean isTimeout = task.getTimedOut();
if (isTimeout) {
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask TIMEOUT: " + taskId);
BackgroundFetch.getInstance(context).finish(taskId);
return;
}
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask: onFetch: " + taskId);
// Perform your work here....
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
SharedPreferences SharedPrefs = context.getSharedPreferences("Gemairo", 0);
String Bearer = SharedPrefs.getString("Tokens", "");
String SchoolURL = SharedPrefs.getString("SchoolURL", "");
String PersonID = SharedPrefs.getString("PersonID", "");
String latestgrades = SharedPrefs.getString("latestGrades", "");
try {
if (latestgrades == "" || PersonID == "" || SchoolURL == "" || Bearer =="") return;
JSONObject Tokens = new JSONObject(Bearer);
final JSONObject latestGrades = new JSONObject(latestgrades);
String CompleteURL = "https://" + SchoolURL.replaceAll("\"", "") + "/api/personen/" + PersonID
+ "/cijfers/laatste?top=50&skip=0";
try {
// Refresh token
URL tokenurl = new URL("https://accounts.magister.net/connect/token");
StringBuffer tokencontent = new StringBuffer();
HttpURLConnection tokencon = (HttpURLConnection) tokenurl.openConnection();
tokencon.setRequestMethod("POST");
tokencon.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
// tokencon.setRequestProperty("Authorization", "Bearer " +
// Tokens.getString("access_token"));
tokencon.setRequestProperty("cache-control", "no-cache");
tokencon.setRequestProperty("x-requested-with", "app.netlob.magiscore");
tokencon.setDoOutput(true);
String body = "refresh_token="+Tokens.getString("refresh_token")+"&client_id=M6LOAPP&grant_type=refresh_token";
byte[] outputInBytes = body.getBytes("UTF-8");
OutputStream os = tokencon.getOutputStream();
os.write(outputInBytes);
os.close();
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(tokencon.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
tokencontent.append(line);
}
}
String tokenresult = tokencontent.toString();
final JSONObject tokenjsonresult = new JSONObject(tokenresult);
//Oplaan van de laatste tokens
SharedPreferences.Editor editor = SharedPrefs.edit();
final JSONObject gemairotokens = new JSONObject();
gemairotokens.put("access_token", tokenjsonresult.getString("access_token"));
gemairotokens.put("id_token", tokenjsonresult.getString("id_token"));
gemairotokens.put("refresh_token", tokenjsonresult.getString("refresh_token"));
editor.putString("Tokens", gemairotokens.toString());
editor.apply();
// Ophalen van de cijfers
URL url = new URL(CompleteURL);
StringBuffer content = new StringBuffer();
HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("GET");
con.setRequestProperty("Content-Type", "application/json");
con.setRequestProperty("Authorization", "Bearer " + tokenjsonresult.getString("access_token"));
con.setRequestProperty("noCache", java.time.Clock.systemUTC().instant().toString());
con.setRequestProperty("x-requested-with", "app.netlob.magiscore");
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(con.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
content.append(line);
}
}
String result = content.toString();
final JSONObject jsonresult = new JSONObject(result);
JSONArray latestGradesItems = (JSONArray) latestGrades.get("items");
Log.d(BackgroundFetch.TAG, latestGradesItems.length() + " - Are latestgrade object's the same? "
+ jsonresult.getString("items").equals(latestGrades.getString("items")));
if (latestGradesItems.length() != 0 && !jsonresult.getString("items").equals(latestGrades.getString("items"))) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
// Als de twee objecten niet hetzelfde zijn stuurt hij een notificatie.
NotificationManager mNotificationManager;
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context.getApplicationContext(),
"Gemairo");
Intent ii = new Intent(context.getPackageManager().getLaunchIntentForPackage("app.netlob.magiscore"));
PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, ii,
PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.BigTextStyle bigText = new NotificationCompat.BigTextStyle();
bigText.bigText("Nieuwe cijfer(s) beschikbaar");
bigText.setBigContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentIntent(pendingIntent);
mBuilder.setSmallIcon(R.drawable.notification);
mBuilder.setContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentText("Nieuwe cijfer(s) beschikbaar");
mBuilder.setPriority(Notification.PRIORITY_HIGH);
mBuilder.setStyle(bigText);
mBuilder.setAutoCancel(true);
mBuilder.setOnlyAlertOnce(true);
mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
String channelId = "Gemairo-Cijfers";
NotificationChannel channel = new NotificationChannel(
channelId,
"Cijfers",
NotificationManager.IMPORTANCE_DEFAULT);
mNotificationManager.createNotificationChannel(channel);
mBuilder.setChannelId(channelId);
}
mNotificationManager.notify(0, mBuilder.build());
} else if (latestGradesItems.length() == 0) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
}
BackgroundFetch.getInstance(context).finish(taskId);
} catch (Exception ex) {
ex.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(ex));
BackgroundFetch.getInstance(context).finish(taskId);
}
} catch (JSONException e) {
e.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(e));
BackgroundFetch.getInstance(context).finish(taskId);
}
}
});
thread.start();
BackgroundFetch.getInstance(context).finish(taskId);
}
} | netlob/magiscore | app/Magiscore/BackgroundFetchHeadlessTask.java | 2,040 | //Oplaan van de laatste tokens | line_comment | nl | // Mensen met meer verstand van java zijn zeer welkom, om de code te verbeteren.
package com.transistorsoft.cordova.backgroundfetch;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.IOException;
import java.net.Socket;
import org.json.*;
import org.json.JSONObject;
import org.json.JSONArray;
import java.lang.Object;
import android.content.SharedPreferences;
import com.transistorsoft.tsbackgroundfetch.BackgroundFetch;
import com.transistorsoft.tsbackgroundfetch.BGTask;
import android.util.Log;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import androidx.core.app.NotificationCompat;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.app.PendingIntent;
import app.netlob.magiscore.R;
public class BackgroundFetchHeadlessTask implements HeadlessTask {
@Override
public void onFetch(Context context, BGTask task) {
String taskId = task.getTaskId();
boolean isTimeout = task.getTimedOut();
if (isTimeout) {
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask TIMEOUT: " + taskId);
BackgroundFetch.getInstance(context).finish(taskId);
return;
}
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask: onFetch: " + taskId);
// Perform your work here....
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
SharedPreferences SharedPrefs = context.getSharedPreferences("Gemairo", 0);
String Bearer = SharedPrefs.getString("Tokens", "");
String SchoolURL = SharedPrefs.getString("SchoolURL", "");
String PersonID = SharedPrefs.getString("PersonID", "");
String latestgrades = SharedPrefs.getString("latestGrades", "");
try {
if (latestgrades == "" || PersonID == "" || SchoolURL == "" || Bearer =="") return;
JSONObject Tokens = new JSONObject(Bearer);
final JSONObject latestGrades = new JSONObject(latestgrades);
String CompleteURL = "https://" + SchoolURL.replaceAll("\"", "") + "/api/personen/" + PersonID
+ "/cijfers/laatste?top=50&skip=0";
try {
// Refresh token
URL tokenurl = new URL("https://accounts.magister.net/connect/token");
StringBuffer tokencontent = new StringBuffer();
HttpURLConnection tokencon = (HttpURLConnection) tokenurl.openConnection();
tokencon.setRequestMethod("POST");
tokencon.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
// tokencon.setRequestProperty("Authorization", "Bearer " +
// Tokens.getString("access_token"));
tokencon.setRequestProperty("cache-control", "no-cache");
tokencon.setRequestProperty("x-requested-with", "app.netlob.magiscore");
tokencon.setDoOutput(true);
String body = "refresh_token="+Tokens.getString("refresh_token")+"&client_id=M6LOAPP&grant_type=refresh_token";
byte[] outputInBytes = body.getBytes("UTF-8");
OutputStream os = tokencon.getOutputStream();
os.write(outputInBytes);
os.close();
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(tokencon.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
tokencontent.append(line);
}
}
String tokenresult = tokencontent.toString();
final JSONObject tokenjsonresult = new JSONObject(tokenresult);
//Oplaan van<SUF>
SharedPreferences.Editor editor = SharedPrefs.edit();
final JSONObject gemairotokens = new JSONObject();
gemairotokens.put("access_token", tokenjsonresult.getString("access_token"));
gemairotokens.put("id_token", tokenjsonresult.getString("id_token"));
gemairotokens.put("refresh_token", tokenjsonresult.getString("refresh_token"));
editor.putString("Tokens", gemairotokens.toString());
editor.apply();
// Ophalen van de cijfers
URL url = new URL(CompleteURL);
StringBuffer content = new StringBuffer();
HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("GET");
con.setRequestProperty("Content-Type", "application/json");
con.setRequestProperty("Authorization", "Bearer " + tokenjsonresult.getString("access_token"));
con.setRequestProperty("noCache", java.time.Clock.systemUTC().instant().toString());
con.setRequestProperty("x-requested-with", "app.netlob.magiscore");
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(con.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
content.append(line);
}
}
String result = content.toString();
final JSONObject jsonresult = new JSONObject(result);
JSONArray latestGradesItems = (JSONArray) latestGrades.get("items");
Log.d(BackgroundFetch.TAG, latestGradesItems.length() + " - Are latestgrade object's the same? "
+ jsonresult.getString("items").equals(latestGrades.getString("items")));
if (latestGradesItems.length() != 0 && !jsonresult.getString("items").equals(latestGrades.getString("items"))) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
// Als de twee objecten niet hetzelfde zijn stuurt hij een notificatie.
NotificationManager mNotificationManager;
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context.getApplicationContext(),
"Gemairo");
Intent ii = new Intent(context.getPackageManager().getLaunchIntentForPackage("app.netlob.magiscore"));
PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, ii,
PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.BigTextStyle bigText = new NotificationCompat.BigTextStyle();
bigText.bigText("Nieuwe cijfer(s) beschikbaar");
bigText.setBigContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentIntent(pendingIntent);
mBuilder.setSmallIcon(R.drawable.notification);
mBuilder.setContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentText("Nieuwe cijfer(s) beschikbaar");
mBuilder.setPriority(Notification.PRIORITY_HIGH);
mBuilder.setStyle(bigText);
mBuilder.setAutoCancel(true);
mBuilder.setOnlyAlertOnce(true);
mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
String channelId = "Gemairo-Cijfers";
NotificationChannel channel = new NotificationChannel(
channelId,
"Cijfers",
NotificationManager.IMPORTANCE_DEFAULT);
mNotificationManager.createNotificationChannel(channel);
mBuilder.setChannelId(channelId);
}
mNotificationManager.notify(0, mBuilder.build());
} else if (latestGradesItems.length() == 0) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
}
BackgroundFetch.getInstance(context).finish(taskId);
} catch (Exception ex) {
ex.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(ex));
BackgroundFetch.getInstance(context).finish(taskId);
}
} catch (JSONException e) {
e.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(e));
BackgroundFetch.getInstance(context).finish(taskId);
}
}
});
thread.start();
BackgroundFetch.getInstance(context).finish(taskId);
}
} |
1670_5 | // Mensen met meer verstand van java zijn zeer welkom, om de code te verbeteren.
package com.transistorsoft.cordova.backgroundfetch;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.IOException;
import java.net.Socket;
import org.json.*;
import org.json.JSONObject;
import org.json.JSONArray;
import java.lang.Object;
import android.content.SharedPreferences;
import com.transistorsoft.tsbackgroundfetch.BackgroundFetch;
import com.transistorsoft.tsbackgroundfetch.BGTask;
import android.util.Log;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import androidx.core.app.NotificationCompat;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.app.PendingIntent;
import app.netlob.magiscore.R;
public class BackgroundFetchHeadlessTask implements HeadlessTask {
@Override
public void onFetch(Context context, BGTask task) {
String taskId = task.getTaskId();
boolean isTimeout = task.getTimedOut();
if (isTimeout) {
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask TIMEOUT: " + taskId);
BackgroundFetch.getInstance(context).finish(taskId);
return;
}
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask: onFetch: " + taskId);
// Perform your work here....
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
SharedPreferences SharedPrefs = context.getSharedPreferences("Gemairo", 0);
String Bearer = SharedPrefs.getString("Tokens", "");
String SchoolURL = SharedPrefs.getString("SchoolURL", "");
String PersonID = SharedPrefs.getString("PersonID", "");
String latestgrades = SharedPrefs.getString("latestGrades", "");
try {
if (latestgrades == "" || PersonID == "" || SchoolURL == "" || Bearer =="") return;
JSONObject Tokens = new JSONObject(Bearer);
final JSONObject latestGrades = new JSONObject(latestgrades);
String CompleteURL = "https://" + SchoolURL.replaceAll("\"", "") + "/api/personen/" + PersonID
+ "/cijfers/laatste?top=50&skip=0";
try {
// Refresh token
URL tokenurl = new URL("https://accounts.magister.net/connect/token");
StringBuffer tokencontent = new StringBuffer();
HttpURLConnection tokencon = (HttpURLConnection) tokenurl.openConnection();
tokencon.setRequestMethod("POST");
tokencon.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
// tokencon.setRequestProperty("Authorization", "Bearer " +
// Tokens.getString("access_token"));
tokencon.setRequestProperty("cache-control", "no-cache");
tokencon.setRequestProperty("x-requested-with", "app.netlob.magiscore");
tokencon.setDoOutput(true);
String body = "refresh_token="+Tokens.getString("refresh_token")+"&client_id=M6LOAPP&grant_type=refresh_token";
byte[] outputInBytes = body.getBytes("UTF-8");
OutputStream os = tokencon.getOutputStream();
os.write(outputInBytes);
os.close();
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(tokencon.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
tokencontent.append(line);
}
}
String tokenresult = tokencontent.toString();
final JSONObject tokenjsonresult = new JSONObject(tokenresult);
//Oplaan van de laatste tokens
SharedPreferences.Editor editor = SharedPrefs.edit();
final JSONObject gemairotokens = new JSONObject();
gemairotokens.put("access_token", tokenjsonresult.getString("access_token"));
gemairotokens.put("id_token", tokenjsonresult.getString("id_token"));
gemairotokens.put("refresh_token", tokenjsonresult.getString("refresh_token"));
editor.putString("Tokens", gemairotokens.toString());
editor.apply();
// Ophalen van de cijfers
URL url = new URL(CompleteURL);
StringBuffer content = new StringBuffer();
HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("GET");
con.setRequestProperty("Content-Type", "application/json");
con.setRequestProperty("Authorization", "Bearer " + tokenjsonresult.getString("access_token"));
con.setRequestProperty("noCache", java.time.Clock.systemUTC().instant().toString());
con.setRequestProperty("x-requested-with", "app.netlob.magiscore");
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(con.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
content.append(line);
}
}
String result = content.toString();
final JSONObject jsonresult = new JSONObject(result);
JSONArray latestGradesItems = (JSONArray) latestGrades.get("items");
Log.d(BackgroundFetch.TAG, latestGradesItems.length() + " - Are latestgrade object's the same? "
+ jsonresult.getString("items").equals(latestGrades.getString("items")));
if (latestGradesItems.length() != 0 && !jsonresult.getString("items").equals(latestGrades.getString("items"))) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
// Als de twee objecten niet hetzelfde zijn stuurt hij een notificatie.
NotificationManager mNotificationManager;
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context.getApplicationContext(),
"Gemairo");
Intent ii = new Intent(context.getPackageManager().getLaunchIntentForPackage("app.netlob.magiscore"));
PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, ii,
PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.BigTextStyle bigText = new NotificationCompat.BigTextStyle();
bigText.bigText("Nieuwe cijfer(s) beschikbaar");
bigText.setBigContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentIntent(pendingIntent);
mBuilder.setSmallIcon(R.drawable.notification);
mBuilder.setContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentText("Nieuwe cijfer(s) beschikbaar");
mBuilder.setPriority(Notification.PRIORITY_HIGH);
mBuilder.setStyle(bigText);
mBuilder.setAutoCancel(true);
mBuilder.setOnlyAlertOnce(true);
mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
String channelId = "Gemairo-Cijfers";
NotificationChannel channel = new NotificationChannel(
channelId,
"Cijfers",
NotificationManager.IMPORTANCE_DEFAULT);
mNotificationManager.createNotificationChannel(channel);
mBuilder.setChannelId(channelId);
}
mNotificationManager.notify(0, mBuilder.build());
} else if (latestGradesItems.length() == 0) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
}
BackgroundFetch.getInstance(context).finish(taskId);
} catch (Exception ex) {
ex.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(ex));
BackgroundFetch.getInstance(context).finish(taskId);
}
} catch (JSONException e) {
e.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(e));
BackgroundFetch.getInstance(context).finish(taskId);
}
}
});
thread.start();
BackgroundFetch.getInstance(context).finish(taskId);
}
} | netlob/magiscore | app/Magiscore/BackgroundFetchHeadlessTask.java | 2,040 | // Ophalen van de cijfers | line_comment | nl | // Mensen met meer verstand van java zijn zeer welkom, om de code te verbeteren.
package com.transistorsoft.cordova.backgroundfetch;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.IOException;
import java.net.Socket;
import org.json.*;
import org.json.JSONObject;
import org.json.JSONArray;
import java.lang.Object;
import android.content.SharedPreferences;
import com.transistorsoft.tsbackgroundfetch.BackgroundFetch;
import com.transistorsoft.tsbackgroundfetch.BGTask;
import android.util.Log;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import androidx.core.app.NotificationCompat;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.app.PendingIntent;
import app.netlob.magiscore.R;
public class BackgroundFetchHeadlessTask implements HeadlessTask {
@Override
public void onFetch(Context context, BGTask task) {
String taskId = task.getTaskId();
boolean isTimeout = task.getTimedOut();
if (isTimeout) {
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask TIMEOUT: " + taskId);
BackgroundFetch.getInstance(context).finish(taskId);
return;
}
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask: onFetch: " + taskId);
// Perform your work here....
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
SharedPreferences SharedPrefs = context.getSharedPreferences("Gemairo", 0);
String Bearer = SharedPrefs.getString("Tokens", "");
String SchoolURL = SharedPrefs.getString("SchoolURL", "");
String PersonID = SharedPrefs.getString("PersonID", "");
String latestgrades = SharedPrefs.getString("latestGrades", "");
try {
if (latestgrades == "" || PersonID == "" || SchoolURL == "" || Bearer =="") return;
JSONObject Tokens = new JSONObject(Bearer);
final JSONObject latestGrades = new JSONObject(latestgrades);
String CompleteURL = "https://" + SchoolURL.replaceAll("\"", "") + "/api/personen/" + PersonID
+ "/cijfers/laatste?top=50&skip=0";
try {
// Refresh token
URL tokenurl = new URL("https://accounts.magister.net/connect/token");
StringBuffer tokencontent = new StringBuffer();
HttpURLConnection tokencon = (HttpURLConnection) tokenurl.openConnection();
tokencon.setRequestMethod("POST");
tokencon.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
// tokencon.setRequestProperty("Authorization", "Bearer " +
// Tokens.getString("access_token"));
tokencon.setRequestProperty("cache-control", "no-cache");
tokencon.setRequestProperty("x-requested-with", "app.netlob.magiscore");
tokencon.setDoOutput(true);
String body = "refresh_token="+Tokens.getString("refresh_token")+"&client_id=M6LOAPP&grant_type=refresh_token";
byte[] outputInBytes = body.getBytes("UTF-8");
OutputStream os = tokencon.getOutputStream();
os.write(outputInBytes);
os.close();
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(tokencon.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
tokencontent.append(line);
}
}
String tokenresult = tokencontent.toString();
final JSONObject tokenjsonresult = new JSONObject(tokenresult);
//Oplaan van de laatste tokens
SharedPreferences.Editor editor = SharedPrefs.edit();
final JSONObject gemairotokens = new JSONObject();
gemairotokens.put("access_token", tokenjsonresult.getString("access_token"));
gemairotokens.put("id_token", tokenjsonresult.getString("id_token"));
gemairotokens.put("refresh_token", tokenjsonresult.getString("refresh_token"));
editor.putString("Tokens", gemairotokens.toString());
editor.apply();
// Ophalen van<SUF>
URL url = new URL(CompleteURL);
StringBuffer content = new StringBuffer();
HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("GET");
con.setRequestProperty("Content-Type", "application/json");
con.setRequestProperty("Authorization", "Bearer " + tokenjsonresult.getString("access_token"));
con.setRequestProperty("noCache", java.time.Clock.systemUTC().instant().toString());
con.setRequestProperty("x-requested-with", "app.netlob.magiscore");
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(con.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
content.append(line);
}
}
String result = content.toString();
final JSONObject jsonresult = new JSONObject(result);
JSONArray latestGradesItems = (JSONArray) latestGrades.get("items");
Log.d(BackgroundFetch.TAG, latestGradesItems.length() + " - Are latestgrade object's the same? "
+ jsonresult.getString("items").equals(latestGrades.getString("items")));
if (latestGradesItems.length() != 0 && !jsonresult.getString("items").equals(latestGrades.getString("items"))) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
// Als de twee objecten niet hetzelfde zijn stuurt hij een notificatie.
NotificationManager mNotificationManager;
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context.getApplicationContext(),
"Gemairo");
Intent ii = new Intent(context.getPackageManager().getLaunchIntentForPackage("app.netlob.magiscore"));
PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, ii,
PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.BigTextStyle bigText = new NotificationCompat.BigTextStyle();
bigText.bigText("Nieuwe cijfer(s) beschikbaar");
bigText.setBigContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentIntent(pendingIntent);
mBuilder.setSmallIcon(R.drawable.notification);
mBuilder.setContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentText("Nieuwe cijfer(s) beschikbaar");
mBuilder.setPriority(Notification.PRIORITY_HIGH);
mBuilder.setStyle(bigText);
mBuilder.setAutoCancel(true);
mBuilder.setOnlyAlertOnce(true);
mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
String channelId = "Gemairo-Cijfers";
NotificationChannel channel = new NotificationChannel(
channelId,
"Cijfers",
NotificationManager.IMPORTANCE_DEFAULT);
mNotificationManager.createNotificationChannel(channel);
mBuilder.setChannelId(channelId);
}
mNotificationManager.notify(0, mBuilder.build());
} else if (latestGradesItems.length() == 0) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
}
BackgroundFetch.getInstance(context).finish(taskId);
} catch (Exception ex) {
ex.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(ex));
BackgroundFetch.getInstance(context).finish(taskId);
}
} catch (JSONException e) {
e.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(e));
BackgroundFetch.getInstance(context).finish(taskId);
}
}
});
thread.start();
BackgroundFetch.getInstance(context).finish(taskId);
}
} |
1670_6 | // Mensen met meer verstand van java zijn zeer welkom, om de code te verbeteren.
package com.transistorsoft.cordova.backgroundfetch;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.IOException;
import java.net.Socket;
import org.json.*;
import org.json.JSONObject;
import org.json.JSONArray;
import java.lang.Object;
import android.content.SharedPreferences;
import com.transistorsoft.tsbackgroundfetch.BackgroundFetch;
import com.transistorsoft.tsbackgroundfetch.BGTask;
import android.util.Log;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import androidx.core.app.NotificationCompat;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.app.PendingIntent;
import app.netlob.magiscore.R;
public class BackgroundFetchHeadlessTask implements HeadlessTask {
@Override
public void onFetch(Context context, BGTask task) {
String taskId = task.getTaskId();
boolean isTimeout = task.getTimedOut();
if (isTimeout) {
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask TIMEOUT: " + taskId);
BackgroundFetch.getInstance(context).finish(taskId);
return;
}
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask: onFetch: " + taskId);
// Perform your work here....
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
SharedPreferences SharedPrefs = context.getSharedPreferences("Gemairo", 0);
String Bearer = SharedPrefs.getString("Tokens", "");
String SchoolURL = SharedPrefs.getString("SchoolURL", "");
String PersonID = SharedPrefs.getString("PersonID", "");
String latestgrades = SharedPrefs.getString("latestGrades", "");
try {
if (latestgrades == "" || PersonID == "" || SchoolURL == "" || Bearer =="") return;
JSONObject Tokens = new JSONObject(Bearer);
final JSONObject latestGrades = new JSONObject(latestgrades);
String CompleteURL = "https://" + SchoolURL.replaceAll("\"", "") + "/api/personen/" + PersonID
+ "/cijfers/laatste?top=50&skip=0";
try {
// Refresh token
URL tokenurl = new URL("https://accounts.magister.net/connect/token");
StringBuffer tokencontent = new StringBuffer();
HttpURLConnection tokencon = (HttpURLConnection) tokenurl.openConnection();
tokencon.setRequestMethod("POST");
tokencon.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
// tokencon.setRequestProperty("Authorization", "Bearer " +
// Tokens.getString("access_token"));
tokencon.setRequestProperty("cache-control", "no-cache");
tokencon.setRequestProperty("x-requested-with", "app.netlob.magiscore");
tokencon.setDoOutput(true);
String body = "refresh_token="+Tokens.getString("refresh_token")+"&client_id=M6LOAPP&grant_type=refresh_token";
byte[] outputInBytes = body.getBytes("UTF-8");
OutputStream os = tokencon.getOutputStream();
os.write(outputInBytes);
os.close();
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(tokencon.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
tokencontent.append(line);
}
}
String tokenresult = tokencontent.toString();
final JSONObject tokenjsonresult = new JSONObject(tokenresult);
//Oplaan van de laatste tokens
SharedPreferences.Editor editor = SharedPrefs.edit();
final JSONObject gemairotokens = new JSONObject();
gemairotokens.put("access_token", tokenjsonresult.getString("access_token"));
gemairotokens.put("id_token", tokenjsonresult.getString("id_token"));
gemairotokens.put("refresh_token", tokenjsonresult.getString("refresh_token"));
editor.putString("Tokens", gemairotokens.toString());
editor.apply();
// Ophalen van de cijfers
URL url = new URL(CompleteURL);
StringBuffer content = new StringBuffer();
HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("GET");
con.setRequestProperty("Content-Type", "application/json");
con.setRequestProperty("Authorization", "Bearer " + tokenjsonresult.getString("access_token"));
con.setRequestProperty("noCache", java.time.Clock.systemUTC().instant().toString());
con.setRequestProperty("x-requested-with", "app.netlob.magiscore");
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(con.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
content.append(line);
}
}
String result = content.toString();
final JSONObject jsonresult = new JSONObject(result);
JSONArray latestGradesItems = (JSONArray) latestGrades.get("items");
Log.d(BackgroundFetch.TAG, latestGradesItems.length() + " - Are latestgrade object's the same? "
+ jsonresult.getString("items").equals(latestGrades.getString("items")));
if (latestGradesItems.length() != 0 && !jsonresult.getString("items").equals(latestGrades.getString("items"))) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
// Als de twee objecten niet hetzelfde zijn stuurt hij een notificatie.
NotificationManager mNotificationManager;
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context.getApplicationContext(),
"Gemairo");
Intent ii = new Intent(context.getPackageManager().getLaunchIntentForPackage("app.netlob.magiscore"));
PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, ii,
PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.BigTextStyle bigText = new NotificationCompat.BigTextStyle();
bigText.bigText("Nieuwe cijfer(s) beschikbaar");
bigText.setBigContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentIntent(pendingIntent);
mBuilder.setSmallIcon(R.drawable.notification);
mBuilder.setContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentText("Nieuwe cijfer(s) beschikbaar");
mBuilder.setPriority(Notification.PRIORITY_HIGH);
mBuilder.setStyle(bigText);
mBuilder.setAutoCancel(true);
mBuilder.setOnlyAlertOnce(true);
mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
String channelId = "Gemairo-Cijfers";
NotificationChannel channel = new NotificationChannel(
channelId,
"Cijfers",
NotificationManager.IMPORTANCE_DEFAULT);
mNotificationManager.createNotificationChannel(channel);
mBuilder.setChannelId(channelId);
}
mNotificationManager.notify(0, mBuilder.build());
} else if (latestGradesItems.length() == 0) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
}
BackgroundFetch.getInstance(context).finish(taskId);
} catch (Exception ex) {
ex.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(ex));
BackgroundFetch.getInstance(context).finish(taskId);
}
} catch (JSONException e) {
e.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(e));
BackgroundFetch.getInstance(context).finish(taskId);
}
}
});
thread.start();
BackgroundFetch.getInstance(context).finish(taskId);
}
} | netlob/magiscore | app/Magiscore/BackgroundFetchHeadlessTask.java | 2,040 | //Opslaan nieuwe cijfers | line_comment | nl | // Mensen met meer verstand van java zijn zeer welkom, om de code te verbeteren.
package com.transistorsoft.cordova.backgroundfetch;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.IOException;
import java.net.Socket;
import org.json.*;
import org.json.JSONObject;
import org.json.JSONArray;
import java.lang.Object;
import android.content.SharedPreferences;
import com.transistorsoft.tsbackgroundfetch.BackgroundFetch;
import com.transistorsoft.tsbackgroundfetch.BGTask;
import android.util.Log;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import androidx.core.app.NotificationCompat;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.app.PendingIntent;
import app.netlob.magiscore.R;
public class BackgroundFetchHeadlessTask implements HeadlessTask {
@Override
public void onFetch(Context context, BGTask task) {
String taskId = task.getTaskId();
boolean isTimeout = task.getTimedOut();
if (isTimeout) {
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask TIMEOUT: " + taskId);
BackgroundFetch.getInstance(context).finish(taskId);
return;
}
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask: onFetch: " + taskId);
// Perform your work here....
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
SharedPreferences SharedPrefs = context.getSharedPreferences("Gemairo", 0);
String Bearer = SharedPrefs.getString("Tokens", "");
String SchoolURL = SharedPrefs.getString("SchoolURL", "");
String PersonID = SharedPrefs.getString("PersonID", "");
String latestgrades = SharedPrefs.getString("latestGrades", "");
try {
if (latestgrades == "" || PersonID == "" || SchoolURL == "" || Bearer =="") return;
JSONObject Tokens = new JSONObject(Bearer);
final JSONObject latestGrades = new JSONObject(latestgrades);
String CompleteURL = "https://" + SchoolURL.replaceAll("\"", "") + "/api/personen/" + PersonID
+ "/cijfers/laatste?top=50&skip=0";
try {
// Refresh token
URL tokenurl = new URL("https://accounts.magister.net/connect/token");
StringBuffer tokencontent = new StringBuffer();
HttpURLConnection tokencon = (HttpURLConnection) tokenurl.openConnection();
tokencon.setRequestMethod("POST");
tokencon.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
// tokencon.setRequestProperty("Authorization", "Bearer " +
// Tokens.getString("access_token"));
tokencon.setRequestProperty("cache-control", "no-cache");
tokencon.setRequestProperty("x-requested-with", "app.netlob.magiscore");
tokencon.setDoOutput(true);
String body = "refresh_token="+Tokens.getString("refresh_token")+"&client_id=M6LOAPP&grant_type=refresh_token";
byte[] outputInBytes = body.getBytes("UTF-8");
OutputStream os = tokencon.getOutputStream();
os.write(outputInBytes);
os.close();
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(tokencon.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
tokencontent.append(line);
}
}
String tokenresult = tokencontent.toString();
final JSONObject tokenjsonresult = new JSONObject(tokenresult);
//Oplaan van de laatste tokens
SharedPreferences.Editor editor = SharedPrefs.edit();
final JSONObject gemairotokens = new JSONObject();
gemairotokens.put("access_token", tokenjsonresult.getString("access_token"));
gemairotokens.put("id_token", tokenjsonresult.getString("id_token"));
gemairotokens.put("refresh_token", tokenjsonresult.getString("refresh_token"));
editor.putString("Tokens", gemairotokens.toString());
editor.apply();
// Ophalen van de cijfers
URL url = new URL(CompleteURL);
StringBuffer content = new StringBuffer();
HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("GET");
con.setRequestProperty("Content-Type", "application/json");
con.setRequestProperty("Authorization", "Bearer " + tokenjsonresult.getString("access_token"));
con.setRequestProperty("noCache", java.time.Clock.systemUTC().instant().toString());
con.setRequestProperty("x-requested-with", "app.netlob.magiscore");
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(con.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
content.append(line);
}
}
String result = content.toString();
final JSONObject jsonresult = new JSONObject(result);
JSONArray latestGradesItems = (JSONArray) latestGrades.get("items");
Log.d(BackgroundFetch.TAG, latestGradesItems.length() + " - Are latestgrade object's the same? "
+ jsonresult.getString("items").equals(latestGrades.getString("items")));
if (latestGradesItems.length() != 0 && !jsonresult.getString("items").equals(latestGrades.getString("items"))) {
//Opslaan nieuwe<SUF>
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
// Als de twee objecten niet hetzelfde zijn stuurt hij een notificatie.
NotificationManager mNotificationManager;
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context.getApplicationContext(),
"Gemairo");
Intent ii = new Intent(context.getPackageManager().getLaunchIntentForPackage("app.netlob.magiscore"));
PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, ii,
PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.BigTextStyle bigText = new NotificationCompat.BigTextStyle();
bigText.bigText("Nieuwe cijfer(s) beschikbaar");
bigText.setBigContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentIntent(pendingIntent);
mBuilder.setSmallIcon(R.drawable.notification);
mBuilder.setContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentText("Nieuwe cijfer(s) beschikbaar");
mBuilder.setPriority(Notification.PRIORITY_HIGH);
mBuilder.setStyle(bigText);
mBuilder.setAutoCancel(true);
mBuilder.setOnlyAlertOnce(true);
mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
String channelId = "Gemairo-Cijfers";
NotificationChannel channel = new NotificationChannel(
channelId,
"Cijfers",
NotificationManager.IMPORTANCE_DEFAULT);
mNotificationManager.createNotificationChannel(channel);
mBuilder.setChannelId(channelId);
}
mNotificationManager.notify(0, mBuilder.build());
} else if (latestGradesItems.length() == 0) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
}
BackgroundFetch.getInstance(context).finish(taskId);
} catch (Exception ex) {
ex.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(ex));
BackgroundFetch.getInstance(context).finish(taskId);
}
} catch (JSONException e) {
e.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(e));
BackgroundFetch.getInstance(context).finish(taskId);
}
}
});
thread.start();
BackgroundFetch.getInstance(context).finish(taskId);
}
} |
1670_7 | // Mensen met meer verstand van java zijn zeer welkom, om de code te verbeteren.
package com.transistorsoft.cordova.backgroundfetch;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.IOException;
import java.net.Socket;
import org.json.*;
import org.json.JSONObject;
import org.json.JSONArray;
import java.lang.Object;
import android.content.SharedPreferences;
import com.transistorsoft.tsbackgroundfetch.BackgroundFetch;
import com.transistorsoft.tsbackgroundfetch.BGTask;
import android.util.Log;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import androidx.core.app.NotificationCompat;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.app.PendingIntent;
import app.netlob.magiscore.R;
public class BackgroundFetchHeadlessTask implements HeadlessTask {
@Override
public void onFetch(Context context, BGTask task) {
String taskId = task.getTaskId();
boolean isTimeout = task.getTimedOut();
if (isTimeout) {
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask TIMEOUT: " + taskId);
BackgroundFetch.getInstance(context).finish(taskId);
return;
}
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask: onFetch: " + taskId);
// Perform your work here....
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
SharedPreferences SharedPrefs = context.getSharedPreferences("Gemairo", 0);
String Bearer = SharedPrefs.getString("Tokens", "");
String SchoolURL = SharedPrefs.getString("SchoolURL", "");
String PersonID = SharedPrefs.getString("PersonID", "");
String latestgrades = SharedPrefs.getString("latestGrades", "");
try {
if (latestgrades == "" || PersonID == "" || SchoolURL == "" || Bearer =="") return;
JSONObject Tokens = new JSONObject(Bearer);
final JSONObject latestGrades = new JSONObject(latestgrades);
String CompleteURL = "https://" + SchoolURL.replaceAll("\"", "") + "/api/personen/" + PersonID
+ "/cijfers/laatste?top=50&skip=0";
try {
// Refresh token
URL tokenurl = new URL("https://accounts.magister.net/connect/token");
StringBuffer tokencontent = new StringBuffer();
HttpURLConnection tokencon = (HttpURLConnection) tokenurl.openConnection();
tokencon.setRequestMethod("POST");
tokencon.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
// tokencon.setRequestProperty("Authorization", "Bearer " +
// Tokens.getString("access_token"));
tokencon.setRequestProperty("cache-control", "no-cache");
tokencon.setRequestProperty("x-requested-with", "app.netlob.magiscore");
tokencon.setDoOutput(true);
String body = "refresh_token="+Tokens.getString("refresh_token")+"&client_id=M6LOAPP&grant_type=refresh_token";
byte[] outputInBytes = body.getBytes("UTF-8");
OutputStream os = tokencon.getOutputStream();
os.write(outputInBytes);
os.close();
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(tokencon.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
tokencontent.append(line);
}
}
String tokenresult = tokencontent.toString();
final JSONObject tokenjsonresult = new JSONObject(tokenresult);
//Oplaan van de laatste tokens
SharedPreferences.Editor editor = SharedPrefs.edit();
final JSONObject gemairotokens = new JSONObject();
gemairotokens.put("access_token", tokenjsonresult.getString("access_token"));
gemairotokens.put("id_token", tokenjsonresult.getString("id_token"));
gemairotokens.put("refresh_token", tokenjsonresult.getString("refresh_token"));
editor.putString("Tokens", gemairotokens.toString());
editor.apply();
// Ophalen van de cijfers
URL url = new URL(CompleteURL);
StringBuffer content = new StringBuffer();
HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("GET");
con.setRequestProperty("Content-Type", "application/json");
con.setRequestProperty("Authorization", "Bearer " + tokenjsonresult.getString("access_token"));
con.setRequestProperty("noCache", java.time.Clock.systemUTC().instant().toString());
con.setRequestProperty("x-requested-with", "app.netlob.magiscore");
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(con.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
content.append(line);
}
}
String result = content.toString();
final JSONObject jsonresult = new JSONObject(result);
JSONArray latestGradesItems = (JSONArray) latestGrades.get("items");
Log.d(BackgroundFetch.TAG, latestGradesItems.length() + " - Are latestgrade object's the same? "
+ jsonresult.getString("items").equals(latestGrades.getString("items")));
if (latestGradesItems.length() != 0 && !jsonresult.getString("items").equals(latestGrades.getString("items"))) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
// Als de twee objecten niet hetzelfde zijn stuurt hij een notificatie.
NotificationManager mNotificationManager;
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context.getApplicationContext(),
"Gemairo");
Intent ii = new Intent(context.getPackageManager().getLaunchIntentForPackage("app.netlob.magiscore"));
PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, ii,
PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.BigTextStyle bigText = new NotificationCompat.BigTextStyle();
bigText.bigText("Nieuwe cijfer(s) beschikbaar");
bigText.setBigContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentIntent(pendingIntent);
mBuilder.setSmallIcon(R.drawable.notification);
mBuilder.setContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentText("Nieuwe cijfer(s) beschikbaar");
mBuilder.setPriority(Notification.PRIORITY_HIGH);
mBuilder.setStyle(bigText);
mBuilder.setAutoCancel(true);
mBuilder.setOnlyAlertOnce(true);
mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
String channelId = "Gemairo-Cijfers";
NotificationChannel channel = new NotificationChannel(
channelId,
"Cijfers",
NotificationManager.IMPORTANCE_DEFAULT);
mNotificationManager.createNotificationChannel(channel);
mBuilder.setChannelId(channelId);
}
mNotificationManager.notify(0, mBuilder.build());
} else if (latestGradesItems.length() == 0) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
}
BackgroundFetch.getInstance(context).finish(taskId);
} catch (Exception ex) {
ex.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(ex));
BackgroundFetch.getInstance(context).finish(taskId);
}
} catch (JSONException e) {
e.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(e));
BackgroundFetch.getInstance(context).finish(taskId);
}
}
});
thread.start();
BackgroundFetch.getInstance(context).finish(taskId);
}
} | netlob/magiscore | app/Magiscore/BackgroundFetchHeadlessTask.java | 2,040 | // Als de twee objecten niet hetzelfde zijn stuurt hij een notificatie. | line_comment | nl | // Mensen met meer verstand van java zijn zeer welkom, om de code te verbeteren.
package com.transistorsoft.cordova.backgroundfetch;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.IOException;
import java.net.Socket;
import org.json.*;
import org.json.JSONObject;
import org.json.JSONArray;
import java.lang.Object;
import android.content.SharedPreferences;
import com.transistorsoft.tsbackgroundfetch.BackgroundFetch;
import com.transistorsoft.tsbackgroundfetch.BGTask;
import android.util.Log;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import androidx.core.app.NotificationCompat;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.app.PendingIntent;
import app.netlob.magiscore.R;
public class BackgroundFetchHeadlessTask implements HeadlessTask {
@Override
public void onFetch(Context context, BGTask task) {
String taskId = task.getTaskId();
boolean isTimeout = task.getTimedOut();
if (isTimeout) {
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask TIMEOUT: " + taskId);
BackgroundFetch.getInstance(context).finish(taskId);
return;
}
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask: onFetch: " + taskId);
// Perform your work here....
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
SharedPreferences SharedPrefs = context.getSharedPreferences("Gemairo", 0);
String Bearer = SharedPrefs.getString("Tokens", "");
String SchoolURL = SharedPrefs.getString("SchoolURL", "");
String PersonID = SharedPrefs.getString("PersonID", "");
String latestgrades = SharedPrefs.getString("latestGrades", "");
try {
if (latestgrades == "" || PersonID == "" || SchoolURL == "" || Bearer =="") return;
JSONObject Tokens = new JSONObject(Bearer);
final JSONObject latestGrades = new JSONObject(latestgrades);
String CompleteURL = "https://" + SchoolURL.replaceAll("\"", "") + "/api/personen/" + PersonID
+ "/cijfers/laatste?top=50&skip=0";
try {
// Refresh token
URL tokenurl = new URL("https://accounts.magister.net/connect/token");
StringBuffer tokencontent = new StringBuffer();
HttpURLConnection tokencon = (HttpURLConnection) tokenurl.openConnection();
tokencon.setRequestMethod("POST");
tokencon.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
// tokencon.setRequestProperty("Authorization", "Bearer " +
// Tokens.getString("access_token"));
tokencon.setRequestProperty("cache-control", "no-cache");
tokencon.setRequestProperty("x-requested-with", "app.netlob.magiscore");
tokencon.setDoOutput(true);
String body = "refresh_token="+Tokens.getString("refresh_token")+"&client_id=M6LOAPP&grant_type=refresh_token";
byte[] outputInBytes = body.getBytes("UTF-8");
OutputStream os = tokencon.getOutputStream();
os.write(outputInBytes);
os.close();
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(tokencon.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
tokencontent.append(line);
}
}
String tokenresult = tokencontent.toString();
final JSONObject tokenjsonresult = new JSONObject(tokenresult);
//Oplaan van de laatste tokens
SharedPreferences.Editor editor = SharedPrefs.edit();
final JSONObject gemairotokens = new JSONObject();
gemairotokens.put("access_token", tokenjsonresult.getString("access_token"));
gemairotokens.put("id_token", tokenjsonresult.getString("id_token"));
gemairotokens.put("refresh_token", tokenjsonresult.getString("refresh_token"));
editor.putString("Tokens", gemairotokens.toString());
editor.apply();
// Ophalen van de cijfers
URL url = new URL(CompleteURL);
StringBuffer content = new StringBuffer();
HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("GET");
con.setRequestProperty("Content-Type", "application/json");
con.setRequestProperty("Authorization", "Bearer " + tokenjsonresult.getString("access_token"));
con.setRequestProperty("noCache", java.time.Clock.systemUTC().instant().toString());
con.setRequestProperty("x-requested-with", "app.netlob.magiscore");
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(con.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
content.append(line);
}
}
String result = content.toString();
final JSONObject jsonresult = new JSONObject(result);
JSONArray latestGradesItems = (JSONArray) latestGrades.get("items");
Log.d(BackgroundFetch.TAG, latestGradesItems.length() + " - Are latestgrade object's the same? "
+ jsonresult.getString("items").equals(latestGrades.getString("items")));
if (latestGradesItems.length() != 0 && !jsonresult.getString("items").equals(latestGrades.getString("items"))) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
// Als de<SUF>
NotificationManager mNotificationManager;
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context.getApplicationContext(),
"Gemairo");
Intent ii = new Intent(context.getPackageManager().getLaunchIntentForPackage("app.netlob.magiscore"));
PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, ii,
PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.BigTextStyle bigText = new NotificationCompat.BigTextStyle();
bigText.bigText("Nieuwe cijfer(s) beschikbaar");
bigText.setBigContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentIntent(pendingIntent);
mBuilder.setSmallIcon(R.drawable.notification);
mBuilder.setContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentText("Nieuwe cijfer(s) beschikbaar");
mBuilder.setPriority(Notification.PRIORITY_HIGH);
mBuilder.setStyle(bigText);
mBuilder.setAutoCancel(true);
mBuilder.setOnlyAlertOnce(true);
mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
String channelId = "Gemairo-Cijfers";
NotificationChannel channel = new NotificationChannel(
channelId,
"Cijfers",
NotificationManager.IMPORTANCE_DEFAULT);
mNotificationManager.createNotificationChannel(channel);
mBuilder.setChannelId(channelId);
}
mNotificationManager.notify(0, mBuilder.build());
} else if (latestGradesItems.length() == 0) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
}
BackgroundFetch.getInstance(context).finish(taskId);
} catch (Exception ex) {
ex.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(ex));
BackgroundFetch.getInstance(context).finish(taskId);
}
} catch (JSONException e) {
e.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(e));
BackgroundFetch.getInstance(context).finish(taskId);
}
}
});
thread.start();
BackgroundFetch.getInstance(context).finish(taskId);
}
} |
1670_8 | // Mensen met meer verstand van java zijn zeer welkom, om de code te verbeteren.
package com.transistorsoft.cordova.backgroundfetch;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.IOException;
import java.net.Socket;
import org.json.*;
import org.json.JSONObject;
import org.json.JSONArray;
import java.lang.Object;
import android.content.SharedPreferences;
import com.transistorsoft.tsbackgroundfetch.BackgroundFetch;
import com.transistorsoft.tsbackgroundfetch.BGTask;
import android.util.Log;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import androidx.core.app.NotificationCompat;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.app.PendingIntent;
import app.netlob.magiscore.R;
public class BackgroundFetchHeadlessTask implements HeadlessTask {
@Override
public void onFetch(Context context, BGTask task) {
String taskId = task.getTaskId();
boolean isTimeout = task.getTimedOut();
if (isTimeout) {
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask TIMEOUT: " + taskId);
BackgroundFetch.getInstance(context).finish(taskId);
return;
}
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask: onFetch: " + taskId);
// Perform your work here....
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
SharedPreferences SharedPrefs = context.getSharedPreferences("Gemairo", 0);
String Bearer = SharedPrefs.getString("Tokens", "");
String SchoolURL = SharedPrefs.getString("SchoolURL", "");
String PersonID = SharedPrefs.getString("PersonID", "");
String latestgrades = SharedPrefs.getString("latestGrades", "");
try {
if (latestgrades == "" || PersonID == "" || SchoolURL == "" || Bearer =="") return;
JSONObject Tokens = new JSONObject(Bearer);
final JSONObject latestGrades = new JSONObject(latestgrades);
String CompleteURL = "https://" + SchoolURL.replaceAll("\"", "") + "/api/personen/" + PersonID
+ "/cijfers/laatste?top=50&skip=0";
try {
// Refresh token
URL tokenurl = new URL("https://accounts.magister.net/connect/token");
StringBuffer tokencontent = new StringBuffer();
HttpURLConnection tokencon = (HttpURLConnection) tokenurl.openConnection();
tokencon.setRequestMethod("POST");
tokencon.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
// tokencon.setRequestProperty("Authorization", "Bearer " +
// Tokens.getString("access_token"));
tokencon.setRequestProperty("cache-control", "no-cache");
tokencon.setRequestProperty("x-requested-with", "app.netlob.magiscore");
tokencon.setDoOutput(true);
String body = "refresh_token="+Tokens.getString("refresh_token")+"&client_id=M6LOAPP&grant_type=refresh_token";
byte[] outputInBytes = body.getBytes("UTF-8");
OutputStream os = tokencon.getOutputStream();
os.write(outputInBytes);
os.close();
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(tokencon.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
tokencontent.append(line);
}
}
String tokenresult = tokencontent.toString();
final JSONObject tokenjsonresult = new JSONObject(tokenresult);
//Oplaan van de laatste tokens
SharedPreferences.Editor editor = SharedPrefs.edit();
final JSONObject gemairotokens = new JSONObject();
gemairotokens.put("access_token", tokenjsonresult.getString("access_token"));
gemairotokens.put("id_token", tokenjsonresult.getString("id_token"));
gemairotokens.put("refresh_token", tokenjsonresult.getString("refresh_token"));
editor.putString("Tokens", gemairotokens.toString());
editor.apply();
// Ophalen van de cijfers
URL url = new URL(CompleteURL);
StringBuffer content = new StringBuffer();
HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("GET");
con.setRequestProperty("Content-Type", "application/json");
con.setRequestProperty("Authorization", "Bearer " + tokenjsonresult.getString("access_token"));
con.setRequestProperty("noCache", java.time.Clock.systemUTC().instant().toString());
con.setRequestProperty("x-requested-with", "app.netlob.magiscore");
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(con.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
content.append(line);
}
}
String result = content.toString();
final JSONObject jsonresult = new JSONObject(result);
JSONArray latestGradesItems = (JSONArray) latestGrades.get("items");
Log.d(BackgroundFetch.TAG, latestGradesItems.length() + " - Are latestgrade object's the same? "
+ jsonresult.getString("items").equals(latestGrades.getString("items")));
if (latestGradesItems.length() != 0 && !jsonresult.getString("items").equals(latestGrades.getString("items"))) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
// Als de twee objecten niet hetzelfde zijn stuurt hij een notificatie.
NotificationManager mNotificationManager;
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context.getApplicationContext(),
"Gemairo");
Intent ii = new Intent(context.getPackageManager().getLaunchIntentForPackage("app.netlob.magiscore"));
PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, ii,
PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.BigTextStyle bigText = new NotificationCompat.BigTextStyle();
bigText.bigText("Nieuwe cijfer(s) beschikbaar");
bigText.setBigContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentIntent(pendingIntent);
mBuilder.setSmallIcon(R.drawable.notification);
mBuilder.setContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentText("Nieuwe cijfer(s) beschikbaar");
mBuilder.setPriority(Notification.PRIORITY_HIGH);
mBuilder.setStyle(bigText);
mBuilder.setAutoCancel(true);
mBuilder.setOnlyAlertOnce(true);
mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
String channelId = "Gemairo-Cijfers";
NotificationChannel channel = new NotificationChannel(
channelId,
"Cijfers",
NotificationManager.IMPORTANCE_DEFAULT);
mNotificationManager.createNotificationChannel(channel);
mBuilder.setChannelId(channelId);
}
mNotificationManager.notify(0, mBuilder.build());
} else if (latestGradesItems.length() == 0) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
}
BackgroundFetch.getInstance(context).finish(taskId);
} catch (Exception ex) {
ex.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(ex));
BackgroundFetch.getInstance(context).finish(taskId);
}
} catch (JSONException e) {
e.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(e));
BackgroundFetch.getInstance(context).finish(taskId);
}
}
});
thread.start();
BackgroundFetch.getInstance(context).finish(taskId);
}
} | netlob/magiscore | app/Magiscore/BackgroundFetchHeadlessTask.java | 2,040 | //Opslaan nieuwe cijfers | line_comment | nl | // Mensen met meer verstand van java zijn zeer welkom, om de code te verbeteren.
package com.transistorsoft.cordova.backgroundfetch;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.IOException;
import java.net.Socket;
import org.json.*;
import org.json.JSONObject;
import org.json.JSONArray;
import java.lang.Object;
import android.content.SharedPreferences;
import com.transistorsoft.tsbackgroundfetch.BackgroundFetch;
import com.transistorsoft.tsbackgroundfetch.BGTask;
import android.util.Log;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import androidx.core.app.NotificationCompat;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.app.PendingIntent;
import app.netlob.magiscore.R;
public class BackgroundFetchHeadlessTask implements HeadlessTask {
@Override
public void onFetch(Context context, BGTask task) {
String taskId = task.getTaskId();
boolean isTimeout = task.getTimedOut();
if (isTimeout) {
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask TIMEOUT: " + taskId);
BackgroundFetch.getInstance(context).finish(taskId);
return;
}
Log.d(BackgroundFetch.TAG, "My BackgroundFetchHeadlessTask: onFetch: " + taskId);
// Perform your work here....
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
SharedPreferences SharedPrefs = context.getSharedPreferences("Gemairo", 0);
String Bearer = SharedPrefs.getString("Tokens", "");
String SchoolURL = SharedPrefs.getString("SchoolURL", "");
String PersonID = SharedPrefs.getString("PersonID", "");
String latestgrades = SharedPrefs.getString("latestGrades", "");
try {
if (latestgrades == "" || PersonID == "" || SchoolURL == "" || Bearer =="") return;
JSONObject Tokens = new JSONObject(Bearer);
final JSONObject latestGrades = new JSONObject(latestgrades);
String CompleteURL = "https://" + SchoolURL.replaceAll("\"", "") + "/api/personen/" + PersonID
+ "/cijfers/laatste?top=50&skip=0";
try {
// Refresh token
URL tokenurl = new URL("https://accounts.magister.net/connect/token");
StringBuffer tokencontent = new StringBuffer();
HttpURLConnection tokencon = (HttpURLConnection) tokenurl.openConnection();
tokencon.setRequestMethod("POST");
tokencon.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
// tokencon.setRequestProperty("Authorization", "Bearer " +
// Tokens.getString("access_token"));
tokencon.setRequestProperty("cache-control", "no-cache");
tokencon.setRequestProperty("x-requested-with", "app.netlob.magiscore");
tokencon.setDoOutput(true);
String body = "refresh_token="+Tokens.getString("refresh_token")+"&client_id=M6LOAPP&grant_type=refresh_token";
byte[] outputInBytes = body.getBytes("UTF-8");
OutputStream os = tokencon.getOutputStream();
os.write(outputInBytes);
os.close();
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(tokencon.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
tokencontent.append(line);
}
}
String tokenresult = tokencontent.toString();
final JSONObject tokenjsonresult = new JSONObject(tokenresult);
//Oplaan van de laatste tokens
SharedPreferences.Editor editor = SharedPrefs.edit();
final JSONObject gemairotokens = new JSONObject();
gemairotokens.put("access_token", tokenjsonresult.getString("access_token"));
gemairotokens.put("id_token", tokenjsonresult.getString("id_token"));
gemairotokens.put("refresh_token", tokenjsonresult.getString("refresh_token"));
editor.putString("Tokens", gemairotokens.toString());
editor.apply();
// Ophalen van de cijfers
URL url = new URL(CompleteURL);
StringBuffer content = new StringBuffer();
HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("GET");
con.setRequestProperty("Content-Type", "application/json");
con.setRequestProperty("Authorization", "Bearer " + tokenjsonresult.getString("access_token"));
con.setRequestProperty("noCache", java.time.Clock.systemUTC().instant().toString());
con.setRequestProperty("x-requested-with", "app.netlob.magiscore");
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(con.getInputStream()))) {
for (String line; (line = reader.readLine()) != null;) {
content.append(line);
}
}
String result = content.toString();
final JSONObject jsonresult = new JSONObject(result);
JSONArray latestGradesItems = (JSONArray) latestGrades.get("items");
Log.d(BackgroundFetch.TAG, latestGradesItems.length() + " - Are latestgrade object's the same? "
+ jsonresult.getString("items").equals(latestGrades.getString("items")));
if (latestGradesItems.length() != 0 && !jsonresult.getString("items").equals(latestGrades.getString("items"))) {
//Opslaan nieuwe cijfers
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
// Als de twee objecten niet hetzelfde zijn stuurt hij een notificatie.
NotificationManager mNotificationManager;
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context.getApplicationContext(),
"Gemairo");
Intent ii = new Intent(context.getPackageManager().getLaunchIntentForPackage("app.netlob.magiscore"));
PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, ii,
PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.BigTextStyle bigText = new NotificationCompat.BigTextStyle();
bigText.bigText("Nieuwe cijfer(s) beschikbaar");
bigText.setBigContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentIntent(pendingIntent);
mBuilder.setSmallIcon(R.drawable.notification);
mBuilder.setContentTitle("Nieuwe cijfers in Gemairo");
mBuilder.setContentText("Nieuwe cijfer(s) beschikbaar");
mBuilder.setPriority(Notification.PRIORITY_HIGH);
mBuilder.setStyle(bigText);
mBuilder.setAutoCancel(true);
mBuilder.setOnlyAlertOnce(true);
mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
String channelId = "Gemairo-Cijfers";
NotificationChannel channel = new NotificationChannel(
channelId,
"Cijfers",
NotificationManager.IMPORTANCE_DEFAULT);
mNotificationManager.createNotificationChannel(channel);
mBuilder.setChannelId(channelId);
}
mNotificationManager.notify(0, mBuilder.build());
} else if (latestGradesItems.length() == 0) {
//Opslaan nieuwe<SUF>
final JSONObject newlatestgrades = new JSONObject();
newlatestgrades.put("items", jsonresult.get("items"));
editor.putString("latestGrades", newlatestgrades.toString());
editor.apply();
}
BackgroundFetch.getInstance(context).finish(taskId);
} catch (Exception ex) {
ex.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(ex));
BackgroundFetch.getInstance(context).finish(taskId);
}
} catch (JSONException e) {
e.printStackTrace();
Log.d(BackgroundFetch.TAG, Log.getStackTraceString(e));
BackgroundFetch.getInstance(context).finish(taskId);
}
}
});
thread.start();
BackgroundFetch.getInstance(context).finish(taskId);
}
} |
1672_0 | package nl.hva;
import java.util.Scanner;
//Gianni Guaita
//IC_106
//programma moet net zolang dobbelstenen gooien totdat er een 6 uitkomt
//de ogen van de dobbelsteen zijn de gegeven karakters van de gebruiker
public class dobbelsteen {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//vraag karakter en pak het eerste karakter ingevoerd in variabel
System.out.println("welk karakter moet ik gebruiken voor het oog?");
String zin = scanner.nextLine();
char karakter = zin.charAt(0);
//do rollen, while x != 6
final int EINDGETAL = 6;
int x;
do {
x = (int) (Math.random() * 6) + 1;
//print alle dobbelstenen met gekozen karakter
if (x == 1) {
System.out.println(" \n " + karakter + " \n " + "\n\n");
} else if (x == 2) {
System.out.println(karakter + " \n \n " + karakter + "\n\n");
} else if (x == 3) {
System.out.println(karakter + " \n " + karakter + " \n " + karakter + "\n\n");
} else if (x == 4) {
System.out.println(karakter + " " + karakter + "\n \n" + karakter + " " + karakter + "\n\n");
} else if (x == 5) {
System.out.println(karakter + " " + karakter + "\n " + karakter + " \n" + karakter + " " + karakter + "\n\n");
} else {
System.out.println(karakter + " " + karakter + "\n" + karakter + " " + karakter + "\n" + karakter + " " + karakter);
}
//System.out.printf("%s %s %s\n", karakter, karakter);
} while (EINDGETAL != x);
{
}
}
}
| montarion/beestigheid | Gianni/Java/dobbelsteen.java | 524 | //programma moet net zolang dobbelstenen gooien totdat er een 6 uitkomt | line_comment | nl | package nl.hva;
import java.util.Scanner;
//Gianni Guaita
//IC_106
//programma moet<SUF>
//de ogen van de dobbelsteen zijn de gegeven karakters van de gebruiker
public class dobbelsteen {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//vraag karakter en pak het eerste karakter ingevoerd in variabel
System.out.println("welk karakter moet ik gebruiken voor het oog?");
String zin = scanner.nextLine();
char karakter = zin.charAt(0);
//do rollen, while x != 6
final int EINDGETAL = 6;
int x;
do {
x = (int) (Math.random() * 6) + 1;
//print alle dobbelstenen met gekozen karakter
if (x == 1) {
System.out.println(" \n " + karakter + " \n " + "\n\n");
} else if (x == 2) {
System.out.println(karakter + " \n \n " + karakter + "\n\n");
} else if (x == 3) {
System.out.println(karakter + " \n " + karakter + " \n " + karakter + "\n\n");
} else if (x == 4) {
System.out.println(karakter + " " + karakter + "\n \n" + karakter + " " + karakter + "\n\n");
} else if (x == 5) {
System.out.println(karakter + " " + karakter + "\n " + karakter + " \n" + karakter + " " + karakter + "\n\n");
} else {
System.out.println(karakter + " " + karakter + "\n" + karakter + " " + karakter + "\n" + karakter + " " + karakter);
}
//System.out.printf("%s %s %s\n", karakter, karakter);
} while (EINDGETAL != x);
{
}
}
}
|
1672_1 | package nl.hva;
import java.util.Scanner;
//Gianni Guaita
//IC_106
//programma moet net zolang dobbelstenen gooien totdat er een 6 uitkomt
//de ogen van de dobbelsteen zijn de gegeven karakters van de gebruiker
public class dobbelsteen {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//vraag karakter en pak het eerste karakter ingevoerd in variabel
System.out.println("welk karakter moet ik gebruiken voor het oog?");
String zin = scanner.nextLine();
char karakter = zin.charAt(0);
//do rollen, while x != 6
final int EINDGETAL = 6;
int x;
do {
x = (int) (Math.random() * 6) + 1;
//print alle dobbelstenen met gekozen karakter
if (x == 1) {
System.out.println(" \n " + karakter + " \n " + "\n\n");
} else if (x == 2) {
System.out.println(karakter + " \n \n " + karakter + "\n\n");
} else if (x == 3) {
System.out.println(karakter + " \n " + karakter + " \n " + karakter + "\n\n");
} else if (x == 4) {
System.out.println(karakter + " " + karakter + "\n \n" + karakter + " " + karakter + "\n\n");
} else if (x == 5) {
System.out.println(karakter + " " + karakter + "\n " + karakter + " \n" + karakter + " " + karakter + "\n\n");
} else {
System.out.println(karakter + " " + karakter + "\n" + karakter + " " + karakter + "\n" + karakter + " " + karakter);
}
//System.out.printf("%s %s %s\n", karakter, karakter);
} while (EINDGETAL != x);
{
}
}
}
| montarion/beestigheid | Gianni/Java/dobbelsteen.java | 524 | //de ogen van de dobbelsteen zijn de gegeven karakters van de gebruiker | line_comment | nl | package nl.hva;
import java.util.Scanner;
//Gianni Guaita
//IC_106
//programma moet net zolang dobbelstenen gooien totdat er een 6 uitkomt
//de ogen<SUF>
public class dobbelsteen {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//vraag karakter en pak het eerste karakter ingevoerd in variabel
System.out.println("welk karakter moet ik gebruiken voor het oog?");
String zin = scanner.nextLine();
char karakter = zin.charAt(0);
//do rollen, while x != 6
final int EINDGETAL = 6;
int x;
do {
x = (int) (Math.random() * 6) + 1;
//print alle dobbelstenen met gekozen karakter
if (x == 1) {
System.out.println(" \n " + karakter + " \n " + "\n\n");
} else if (x == 2) {
System.out.println(karakter + " \n \n " + karakter + "\n\n");
} else if (x == 3) {
System.out.println(karakter + " \n " + karakter + " \n " + karakter + "\n\n");
} else if (x == 4) {
System.out.println(karakter + " " + karakter + "\n \n" + karakter + " " + karakter + "\n\n");
} else if (x == 5) {
System.out.println(karakter + " " + karakter + "\n " + karakter + " \n" + karakter + " " + karakter + "\n\n");
} else {
System.out.println(karakter + " " + karakter + "\n" + karakter + " " + karakter + "\n" + karakter + " " + karakter);
}
//System.out.printf("%s %s %s\n", karakter, karakter);
} while (EINDGETAL != x);
{
}
}
}
|
1672_4 | package nl.hva;
import java.util.Scanner;
//Gianni Guaita
//IC_106
//programma moet net zolang dobbelstenen gooien totdat er een 6 uitkomt
//de ogen van de dobbelsteen zijn de gegeven karakters van de gebruiker
public class dobbelsteen {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//vraag karakter en pak het eerste karakter ingevoerd in variabel
System.out.println("welk karakter moet ik gebruiken voor het oog?");
String zin = scanner.nextLine();
char karakter = zin.charAt(0);
//do rollen, while x != 6
final int EINDGETAL = 6;
int x;
do {
x = (int) (Math.random() * 6) + 1;
//print alle dobbelstenen met gekozen karakter
if (x == 1) {
System.out.println(" \n " + karakter + " \n " + "\n\n");
} else if (x == 2) {
System.out.println(karakter + " \n \n " + karakter + "\n\n");
} else if (x == 3) {
System.out.println(karakter + " \n " + karakter + " \n " + karakter + "\n\n");
} else if (x == 4) {
System.out.println(karakter + " " + karakter + "\n \n" + karakter + " " + karakter + "\n\n");
} else if (x == 5) {
System.out.println(karakter + " " + karakter + "\n " + karakter + " \n" + karakter + " " + karakter + "\n\n");
} else {
System.out.println(karakter + " " + karakter + "\n" + karakter + " " + karakter + "\n" + karakter + " " + karakter);
}
//System.out.printf("%s %s %s\n", karakter, karakter);
} while (EINDGETAL != x);
{
}
}
}
| montarion/beestigheid | Gianni/Java/dobbelsteen.java | 524 | //print alle dobbelstenen met gekozen karakter | line_comment | nl | package nl.hva;
import java.util.Scanner;
//Gianni Guaita
//IC_106
//programma moet net zolang dobbelstenen gooien totdat er een 6 uitkomt
//de ogen van de dobbelsteen zijn de gegeven karakters van de gebruiker
public class dobbelsteen {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//vraag karakter en pak het eerste karakter ingevoerd in variabel
System.out.println("welk karakter moet ik gebruiken voor het oog?");
String zin = scanner.nextLine();
char karakter = zin.charAt(0);
//do rollen, while x != 6
final int EINDGETAL = 6;
int x;
do {
x = (int) (Math.random() * 6) + 1;
//print alle<SUF>
if (x == 1) {
System.out.println(" \n " + karakter + " \n " + "\n\n");
} else if (x == 2) {
System.out.println(karakter + " \n \n " + karakter + "\n\n");
} else if (x == 3) {
System.out.println(karakter + " \n " + karakter + " \n " + karakter + "\n\n");
} else if (x == 4) {
System.out.println(karakter + " " + karakter + "\n \n" + karakter + " " + karakter + "\n\n");
} else if (x == 5) {
System.out.println(karakter + " " + karakter + "\n " + karakter + " \n" + karakter + " " + karakter + "\n\n");
} else {
System.out.println(karakter + " " + karakter + "\n" + karakter + " " + karakter + "\n" + karakter + " " + karakter);
}
//System.out.printf("%s %s %s\n", karakter, karakter);
} while (EINDGETAL != x);
{
}
}
}
|
1673_1 | import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
/**
* Blust branden die zijn ontstaan door kortsluiting.
*
* Project 42
*/
public class ControlroomExtinguish extends ControlroomIntervention
{
public void addedToWorld(World world)
{
// Dit moet een werkende .GIF zijn
setImage("firefighter.gif");
}
public void act()
{
super.act();
}
}
| Project42/game2 | ControlroomExtinguish.java | 122 | /**
* Blust branden die zijn ontstaan door kortsluiting.
*
* Project 42
*/ | block_comment | nl | import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
/**
* Blust branden die<SUF>*/
public class ControlroomExtinguish extends ControlroomIntervention
{
public void addedToWorld(World world)
{
// Dit moet een werkende .GIF zijn
setImage("firefighter.gif");
}
public void act()
{
super.act();
}
}
|
1673_2 | import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
/**
* Blust branden die zijn ontstaan door kortsluiting.
*
* Project 42
*/
public class ControlroomExtinguish extends ControlroomIntervention
{
public void addedToWorld(World world)
{
// Dit moet een werkende .GIF zijn
setImage("firefighter.gif");
}
public void act()
{
super.act();
}
}
| Project42/game2 | ControlroomExtinguish.java | 122 | // Dit moet een werkende .GIF zijn | line_comment | nl | import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
/**
* Blust branden die zijn ontstaan door kortsluiting.
*
* Project 42
*/
public class ControlroomExtinguish extends ControlroomIntervention
{
public void addedToWorld(World world)
{
// Dit moet<SUF>
setImage("firefighter.gif");
}
public void act()
{
super.act();
}
}
|
1674_0 | import greenfoot.*;
/**
* Politie vangt boeven die aan het plunderen zijn.
*
* Project 42
*/
public class ControlroomCatchThief extends ControlroomIntervention
{
public void addedToWorld(World world)
{
// Dit moet een werkende .GIF zijn
setImage("thief_chasing.gif");
}
public void act()
{
super.act();
}
} | Project42/game2 | ControlroomCatchThief.java | 107 | /**
* Politie vangt boeven die aan het plunderen zijn.
*
* Project 42
*/ | block_comment | nl | import greenfoot.*;
/**
* Politie vangt boeven<SUF>*/
public class ControlroomCatchThief extends ControlroomIntervention
{
public void addedToWorld(World world)
{
// Dit moet een werkende .GIF zijn
setImage("thief_chasing.gif");
}
public void act()
{
super.act();
}
} |
1674_1 | import greenfoot.*;
/**
* Politie vangt boeven die aan het plunderen zijn.
*
* Project 42
*/
public class ControlroomCatchThief extends ControlroomIntervention
{
public void addedToWorld(World world)
{
// Dit moet een werkende .GIF zijn
setImage("thief_chasing.gif");
}
public void act()
{
super.act();
}
} | Project42/game2 | ControlroomCatchThief.java | 107 | // Dit moet een werkende .GIF zijn | line_comment | nl | import greenfoot.*;
/**
* Politie vangt boeven die aan het plunderen zijn.
*
* Project 42
*/
public class ControlroomCatchThief extends ControlroomIntervention
{
public void addedToWorld(World world)
{
// Dit moet<SUF>
setImage("thief_chasing.gif");
}
public void act()
{
super.act();
}
} |
1676_0 | import java.util.HashSet;
import java.util.Objects;
import java.util.Scanner;
public class Bonus {
public static void main(String[] args) {
// Onderstaande code is uitgecommentarieerd. Haal de code uit de comment (delete /* en */) om aan de slag te gaan met de bonus
// In de code staan op verschillende plekken comments tussen "/*...*/" als hint wat je moet doen
HashSet<Integer> secretnumber = randomnumbergenerator();
String stringnumber = setToStringConverter(secretnumber);
System.out.println(stringnumber);
feedback(/*vul hier het juiste argument in*/);
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ randomnumbergenerator(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak een nieuwe variabele van type Random. (Tip: Zoek op internet hoe je Random kunt gebruiken)
- Maak een nieuwe variabele van type HashSet.
- Schrijf een while-loop om 4 random nummers aan de hashset toe te voegen
- return de hashset
*/
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ setToStringConverter(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak als eerst een String variabele met als waarde een lege String. (of gebruik een StringBuilder)
- Schrijf vervolgens een for-loop om de items in de hashset een voor een aan de String variabele toe te voegen.
- Return de (gevulde) String variabele
*/
}
public static void/*moet dit "void" zijn of wat anders?*/ feedback(String stringnumber) {
Scanner scanner = new Scanner(System.in);
StringBuilder feedback = new StringBuilder();
System.out.println("+ = juiste nummer op de juiste plek, O = juiste nummer verkeerde plek, X = verkeerde nummer");
System.out.println("Doe een gok, Let op vul 4 getallen in.");
String guess = scanner.nextLine();
if (Objects.equals(guess, stringnumber)) {
System.out.println("gefeliciteerd je hebt het goed");
} else {
for (int i = 0; i < 4; i++) {
if (guess.substring(i, i + 1).equals(stringnumber.substring(i, i + 1))) {
feedback.append("+");
} else if (stringnumber.contains(guess.substring(i, i + 1))) {
feedback.append("0");
} else {
feedback.append("X");
}
}
}
System.out.println(feedback.toString());
}
}
| hogeschoolnovi/backend-java-collecties-lussen | src/Bonus.java | 673 | // Onderstaande code is uitgecommentarieerd. Haal de code uit de comment (delete /* en */) om aan de slag te gaan met de bonus | line_comment | nl | import java.util.HashSet;
import java.util.Objects;
import java.util.Scanner;
public class Bonus {
public static void main(String[] args) {
// Onderstaande code<SUF>
// In de code staan op verschillende plekken comments tussen "/*...*/" als hint wat je moet doen
HashSet<Integer> secretnumber = randomnumbergenerator();
String stringnumber = setToStringConverter(secretnumber);
System.out.println(stringnumber);
feedback(/*vul hier het juiste argument in*/);
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ randomnumbergenerator(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak een nieuwe variabele van type Random. (Tip: Zoek op internet hoe je Random kunt gebruiken)
- Maak een nieuwe variabele van type HashSet.
- Schrijf een while-loop om 4 random nummers aan de hashset toe te voegen
- return de hashset
*/
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ setToStringConverter(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak als eerst een String variabele met als waarde een lege String. (of gebruik een StringBuilder)
- Schrijf vervolgens een for-loop om de items in de hashset een voor een aan de String variabele toe te voegen.
- Return de (gevulde) String variabele
*/
}
public static void/*moet dit "void" zijn of wat anders?*/ feedback(String stringnumber) {
Scanner scanner = new Scanner(System.in);
StringBuilder feedback = new StringBuilder();
System.out.println("+ = juiste nummer op de juiste plek, O = juiste nummer verkeerde plek, X = verkeerde nummer");
System.out.println("Doe een gok, Let op vul 4 getallen in.");
String guess = scanner.nextLine();
if (Objects.equals(guess, stringnumber)) {
System.out.println("gefeliciteerd je hebt het goed");
} else {
for (int i = 0; i < 4; i++) {
if (guess.substring(i, i + 1).equals(stringnumber.substring(i, i + 1))) {
feedback.append("+");
} else if (stringnumber.contains(guess.substring(i, i + 1))) {
feedback.append("0");
} else {
feedback.append("X");
}
}
}
System.out.println(feedback.toString());
}
}
|
1676_1 | import java.util.HashSet;
import java.util.Objects;
import java.util.Scanner;
public class Bonus {
public static void main(String[] args) {
// Onderstaande code is uitgecommentarieerd. Haal de code uit de comment (delete /* en */) om aan de slag te gaan met de bonus
// In de code staan op verschillende plekken comments tussen "/*...*/" als hint wat je moet doen
HashSet<Integer> secretnumber = randomnumbergenerator();
String stringnumber = setToStringConverter(secretnumber);
System.out.println(stringnumber);
feedback(/*vul hier het juiste argument in*/);
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ randomnumbergenerator(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak een nieuwe variabele van type Random. (Tip: Zoek op internet hoe je Random kunt gebruiken)
- Maak een nieuwe variabele van type HashSet.
- Schrijf een while-loop om 4 random nummers aan de hashset toe te voegen
- return de hashset
*/
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ setToStringConverter(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak als eerst een String variabele met als waarde een lege String. (of gebruik een StringBuilder)
- Schrijf vervolgens een for-loop om de items in de hashset een voor een aan de String variabele toe te voegen.
- Return de (gevulde) String variabele
*/
}
public static void/*moet dit "void" zijn of wat anders?*/ feedback(String stringnumber) {
Scanner scanner = new Scanner(System.in);
StringBuilder feedback = new StringBuilder();
System.out.println("+ = juiste nummer op de juiste plek, O = juiste nummer verkeerde plek, X = verkeerde nummer");
System.out.println("Doe een gok, Let op vul 4 getallen in.");
String guess = scanner.nextLine();
if (Objects.equals(guess, stringnumber)) {
System.out.println("gefeliciteerd je hebt het goed");
} else {
for (int i = 0; i < 4; i++) {
if (guess.substring(i, i + 1).equals(stringnumber.substring(i, i + 1))) {
feedback.append("+");
} else if (stringnumber.contains(guess.substring(i, i + 1))) {
feedback.append("0");
} else {
feedback.append("X");
}
}
}
System.out.println(feedback.toString());
}
}
| hogeschoolnovi/backend-java-collecties-lussen | src/Bonus.java | 673 | // In de code staan op verschillende plekken comments tussen "/*...*/" als hint wat je moet doen | line_comment | nl | import java.util.HashSet;
import java.util.Objects;
import java.util.Scanner;
public class Bonus {
public static void main(String[] args) {
// Onderstaande code is uitgecommentarieerd. Haal de code uit de comment (delete /* en */) om aan de slag te gaan met de bonus
// In de<SUF>
HashSet<Integer> secretnumber = randomnumbergenerator();
String stringnumber = setToStringConverter(secretnumber);
System.out.println(stringnumber);
feedback(/*vul hier het juiste argument in*/);
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ randomnumbergenerator(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak een nieuwe variabele van type Random. (Tip: Zoek op internet hoe je Random kunt gebruiken)
- Maak een nieuwe variabele van type HashSet.
- Schrijf een while-loop om 4 random nummers aan de hashset toe te voegen
- return de hashset
*/
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ setToStringConverter(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak als eerst een String variabele met als waarde een lege String. (of gebruik een StringBuilder)
- Schrijf vervolgens een for-loop om de items in de hashset een voor een aan de String variabele toe te voegen.
- Return de (gevulde) String variabele
*/
}
public static void/*moet dit "void" zijn of wat anders?*/ feedback(String stringnumber) {
Scanner scanner = new Scanner(System.in);
StringBuilder feedback = new StringBuilder();
System.out.println("+ = juiste nummer op de juiste plek, O = juiste nummer verkeerde plek, X = verkeerde nummer");
System.out.println("Doe een gok, Let op vul 4 getallen in.");
String guess = scanner.nextLine();
if (Objects.equals(guess, stringnumber)) {
System.out.println("gefeliciteerd je hebt het goed");
} else {
for (int i = 0; i < 4; i++) {
if (guess.substring(i, i + 1).equals(stringnumber.substring(i, i + 1))) {
feedback.append("+");
} else if (stringnumber.contains(guess.substring(i, i + 1))) {
feedback.append("0");
} else {
feedback.append("X");
}
}
}
System.out.println(feedback.toString());
}
}
|
1676_2 | import java.util.HashSet;
import java.util.Objects;
import java.util.Scanner;
public class Bonus {
public static void main(String[] args) {
// Onderstaande code is uitgecommentarieerd. Haal de code uit de comment (delete /* en */) om aan de slag te gaan met de bonus
// In de code staan op verschillende plekken comments tussen "/*...*/" als hint wat je moet doen
HashSet<Integer> secretnumber = randomnumbergenerator();
String stringnumber = setToStringConverter(secretnumber);
System.out.println(stringnumber);
feedback(/*vul hier het juiste argument in*/);
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ randomnumbergenerator(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak een nieuwe variabele van type Random. (Tip: Zoek op internet hoe je Random kunt gebruiken)
- Maak een nieuwe variabele van type HashSet.
- Schrijf een while-loop om 4 random nummers aan de hashset toe te voegen
- return de hashset
*/
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ setToStringConverter(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak als eerst een String variabele met als waarde een lege String. (of gebruik een StringBuilder)
- Schrijf vervolgens een for-loop om de items in de hashset een voor een aan de String variabele toe te voegen.
- Return de (gevulde) String variabele
*/
}
public static void/*moet dit "void" zijn of wat anders?*/ feedback(String stringnumber) {
Scanner scanner = new Scanner(System.in);
StringBuilder feedback = new StringBuilder();
System.out.println("+ = juiste nummer op de juiste plek, O = juiste nummer verkeerde plek, X = verkeerde nummer");
System.out.println("Doe een gok, Let op vul 4 getallen in.");
String guess = scanner.nextLine();
if (Objects.equals(guess, stringnumber)) {
System.out.println("gefeliciteerd je hebt het goed");
} else {
for (int i = 0; i < 4; i++) {
if (guess.substring(i, i + 1).equals(stringnumber.substring(i, i + 1))) {
feedback.append("+");
} else if (stringnumber.contains(guess.substring(i, i + 1))) {
feedback.append("0");
} else {
feedback.append("X");
}
}
}
System.out.println(feedback.toString());
}
}
| hogeschoolnovi/backend-java-collecties-lussen | src/Bonus.java | 673 | /*vul hier het juiste argument in*/ | block_comment | nl | import java.util.HashSet;
import java.util.Objects;
import java.util.Scanner;
public class Bonus {
public static void main(String[] args) {
// Onderstaande code is uitgecommentarieerd. Haal de code uit de comment (delete /* en */) om aan de slag te gaan met de bonus
// In de code staan op verschillende plekken comments tussen "/*...*/" als hint wat je moet doen
HashSet<Integer> secretnumber = randomnumbergenerator();
String stringnumber = setToStringConverter(secretnumber);
System.out.println(stringnumber);
feedback(/*vul hier het<SUF>*/);
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ randomnumbergenerator(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak een nieuwe variabele van type Random. (Tip: Zoek op internet hoe je Random kunt gebruiken)
- Maak een nieuwe variabele van type HashSet.
- Schrijf een while-loop om 4 random nummers aan de hashset toe te voegen
- return de hashset
*/
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ setToStringConverter(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak als eerst een String variabele met als waarde een lege String. (of gebruik een StringBuilder)
- Schrijf vervolgens een for-loop om de items in de hashset een voor een aan de String variabele toe te voegen.
- Return de (gevulde) String variabele
*/
}
public static void/*moet dit "void" zijn of wat anders?*/ feedback(String stringnumber) {
Scanner scanner = new Scanner(System.in);
StringBuilder feedback = new StringBuilder();
System.out.println("+ = juiste nummer op de juiste plek, O = juiste nummer verkeerde plek, X = verkeerde nummer");
System.out.println("Doe een gok, Let op vul 4 getallen in.");
String guess = scanner.nextLine();
if (Objects.equals(guess, stringnumber)) {
System.out.println("gefeliciteerd je hebt het goed");
} else {
for (int i = 0; i < 4; i++) {
if (guess.substring(i, i + 1).equals(stringnumber.substring(i, i + 1))) {
feedback.append("+");
} else if (stringnumber.contains(guess.substring(i, i + 1))) {
feedback.append("0");
} else {
feedback.append("X");
}
}
}
System.out.println(feedback.toString());
}
}
|
1676_3 | import java.util.HashSet;
import java.util.Objects;
import java.util.Scanner;
public class Bonus {
public static void main(String[] args) {
// Onderstaande code is uitgecommentarieerd. Haal de code uit de comment (delete /* en */) om aan de slag te gaan met de bonus
// In de code staan op verschillende plekken comments tussen "/*...*/" als hint wat je moet doen
HashSet<Integer> secretnumber = randomnumbergenerator();
String stringnumber = setToStringConverter(secretnumber);
System.out.println(stringnumber);
feedback(/*vul hier het juiste argument in*/);
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ randomnumbergenerator(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak een nieuwe variabele van type Random. (Tip: Zoek op internet hoe je Random kunt gebruiken)
- Maak een nieuwe variabele van type HashSet.
- Schrijf een while-loop om 4 random nummers aan de hashset toe te voegen
- return de hashset
*/
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ setToStringConverter(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak als eerst een String variabele met als waarde een lege String. (of gebruik een StringBuilder)
- Schrijf vervolgens een for-loop om de items in de hashset een voor een aan de String variabele toe te voegen.
- Return de (gevulde) String variabele
*/
}
public static void/*moet dit "void" zijn of wat anders?*/ feedback(String stringnumber) {
Scanner scanner = new Scanner(System.in);
StringBuilder feedback = new StringBuilder();
System.out.println("+ = juiste nummer op de juiste plek, O = juiste nummer verkeerde plek, X = verkeerde nummer");
System.out.println("Doe een gok, Let op vul 4 getallen in.");
String guess = scanner.nextLine();
if (Objects.equals(guess, stringnumber)) {
System.out.println("gefeliciteerd je hebt het goed");
} else {
for (int i = 0; i < 4; i++) {
if (guess.substring(i, i + 1).equals(stringnumber.substring(i, i + 1))) {
feedback.append("+");
} else if (stringnumber.contains(guess.substring(i, i + 1))) {
feedback.append("0");
} else {
feedback.append("X");
}
}
}
System.out.println(feedback.toString());
}
}
| hogeschoolnovi/backend-java-collecties-lussen | src/Bonus.java | 673 | /*moet dit returntype "void" zijn of wat anders?*/ | block_comment | nl | import java.util.HashSet;
import java.util.Objects;
import java.util.Scanner;
public class Bonus {
public static void main(String[] args) {
// Onderstaande code is uitgecommentarieerd. Haal de code uit de comment (delete /* en */) om aan de slag te gaan met de bonus
// In de code staan op verschillende plekken comments tussen "/*...*/" als hint wat je moet doen
HashSet<Integer> secretnumber = randomnumbergenerator();
String stringnumber = setToStringConverter(secretnumber);
System.out.println(stringnumber);
feedback(/*vul hier het juiste argument in*/);
}
public static void/*moet dit returntype<SUF>*/ randomnumbergenerator(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak een nieuwe variabele van type Random. (Tip: Zoek op internet hoe je Random kunt gebruiken)
- Maak een nieuwe variabele van type HashSet.
- Schrijf een while-loop om 4 random nummers aan de hashset toe te voegen
- return de hashset
*/
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ setToStringConverter(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak als eerst een String variabele met als waarde een lege String. (of gebruik een StringBuilder)
- Schrijf vervolgens een for-loop om de items in de hashset een voor een aan de String variabele toe te voegen.
- Return de (gevulde) String variabele
*/
}
public static void/*moet dit "void" zijn of wat anders?*/ feedback(String stringnumber) {
Scanner scanner = new Scanner(System.in);
StringBuilder feedback = new StringBuilder();
System.out.println("+ = juiste nummer op de juiste plek, O = juiste nummer verkeerde plek, X = verkeerde nummer");
System.out.println("Doe een gok, Let op vul 4 getallen in.");
String guess = scanner.nextLine();
if (Objects.equals(guess, stringnumber)) {
System.out.println("gefeliciteerd je hebt het goed");
} else {
for (int i = 0; i < 4; i++) {
if (guess.substring(i, i + 1).equals(stringnumber.substring(i, i + 1))) {
feedback.append("+");
} else if (stringnumber.contains(guess.substring(i, i + 1))) {
feedback.append("0");
} else {
feedback.append("X");
}
}
}
System.out.println(feedback.toString());
}
}
|
1676_4 | import java.util.HashSet;
import java.util.Objects;
import java.util.Scanner;
public class Bonus {
public static void main(String[] args) {
// Onderstaande code is uitgecommentarieerd. Haal de code uit de comment (delete /* en */) om aan de slag te gaan met de bonus
// In de code staan op verschillende plekken comments tussen "/*...*/" als hint wat je moet doen
HashSet<Integer> secretnumber = randomnumbergenerator();
String stringnumber = setToStringConverter(secretnumber);
System.out.println(stringnumber);
feedback(/*vul hier het juiste argument in*/);
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ randomnumbergenerator(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak een nieuwe variabele van type Random. (Tip: Zoek op internet hoe je Random kunt gebruiken)
- Maak een nieuwe variabele van type HashSet.
- Schrijf een while-loop om 4 random nummers aan de hashset toe te voegen
- return de hashset
*/
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ setToStringConverter(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak als eerst een String variabele met als waarde een lege String. (of gebruik een StringBuilder)
- Schrijf vervolgens een for-loop om de items in de hashset een voor een aan de String variabele toe te voegen.
- Return de (gevulde) String variabele
*/
}
public static void/*moet dit "void" zijn of wat anders?*/ feedback(String stringnumber) {
Scanner scanner = new Scanner(System.in);
StringBuilder feedback = new StringBuilder();
System.out.println("+ = juiste nummer op de juiste plek, O = juiste nummer verkeerde plek, X = verkeerde nummer");
System.out.println("Doe een gok, Let op vul 4 getallen in.");
String guess = scanner.nextLine();
if (Objects.equals(guess, stringnumber)) {
System.out.println("gefeliciteerd je hebt het goed");
} else {
for (int i = 0; i < 4; i++) {
if (guess.substring(i, i + 1).equals(stringnumber.substring(i, i + 1))) {
feedback.append("+");
} else if (stringnumber.contains(guess.substring(i, i + 1))) {
feedback.append("0");
} else {
feedback.append("X");
}
}
}
System.out.println(feedback.toString());
}
}
| hogeschoolnovi/backend-java-collecties-lussen | src/Bonus.java | 673 | /*Heeft deze methode nog parameter(s) nodig?*/ | block_comment | nl | import java.util.HashSet;
import java.util.Objects;
import java.util.Scanner;
public class Bonus {
public static void main(String[] args) {
// Onderstaande code is uitgecommentarieerd. Haal de code uit de comment (delete /* en */) om aan de slag te gaan met de bonus
// In de code staan op verschillende plekken comments tussen "/*...*/" als hint wat je moet doen
HashSet<Integer> secretnumber = randomnumbergenerator();
String stringnumber = setToStringConverter(secretnumber);
System.out.println(stringnumber);
feedback(/*vul hier het juiste argument in*/);
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ randomnumbergenerator(/*Heeft deze methode<SUF>*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak een nieuwe variabele van type Random. (Tip: Zoek op internet hoe je Random kunt gebruiken)
- Maak een nieuwe variabele van type HashSet.
- Schrijf een while-loop om 4 random nummers aan de hashset toe te voegen
- return de hashset
*/
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ setToStringConverter(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak als eerst een String variabele met als waarde een lege String. (of gebruik een StringBuilder)
- Schrijf vervolgens een for-loop om de items in de hashset een voor een aan de String variabele toe te voegen.
- Return de (gevulde) String variabele
*/
}
public static void/*moet dit "void" zijn of wat anders?*/ feedback(String stringnumber) {
Scanner scanner = new Scanner(System.in);
StringBuilder feedback = new StringBuilder();
System.out.println("+ = juiste nummer op de juiste plek, O = juiste nummer verkeerde plek, X = verkeerde nummer");
System.out.println("Doe een gok, Let op vul 4 getallen in.");
String guess = scanner.nextLine();
if (Objects.equals(guess, stringnumber)) {
System.out.println("gefeliciteerd je hebt het goed");
} else {
for (int i = 0; i < 4; i++) {
if (guess.substring(i, i + 1).equals(stringnumber.substring(i, i + 1))) {
feedback.append("+");
} else if (stringnumber.contains(guess.substring(i, i + 1))) {
feedback.append("0");
} else {
feedback.append("X");
}
}
}
System.out.println(feedback.toString());
}
}
|
1676_5 | import java.util.HashSet;
import java.util.Objects;
import java.util.Scanner;
public class Bonus {
public static void main(String[] args) {
// Onderstaande code is uitgecommentarieerd. Haal de code uit de comment (delete /* en */) om aan de slag te gaan met de bonus
// In de code staan op verschillende plekken comments tussen "/*...*/" als hint wat je moet doen
HashSet<Integer> secretnumber = randomnumbergenerator();
String stringnumber = setToStringConverter(secretnumber);
System.out.println(stringnumber);
feedback(/*vul hier het juiste argument in*/);
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ randomnumbergenerator(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak een nieuwe variabele van type Random. (Tip: Zoek op internet hoe je Random kunt gebruiken)
- Maak een nieuwe variabele van type HashSet.
- Schrijf een while-loop om 4 random nummers aan de hashset toe te voegen
- return de hashset
*/
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ setToStringConverter(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak als eerst een String variabele met als waarde een lege String. (of gebruik een StringBuilder)
- Schrijf vervolgens een for-loop om de items in de hashset een voor een aan de String variabele toe te voegen.
- Return de (gevulde) String variabele
*/
}
public static void/*moet dit "void" zijn of wat anders?*/ feedback(String stringnumber) {
Scanner scanner = new Scanner(System.in);
StringBuilder feedback = new StringBuilder();
System.out.println("+ = juiste nummer op de juiste plek, O = juiste nummer verkeerde plek, X = verkeerde nummer");
System.out.println("Doe een gok, Let op vul 4 getallen in.");
String guess = scanner.nextLine();
if (Objects.equals(guess, stringnumber)) {
System.out.println("gefeliciteerd je hebt het goed");
} else {
for (int i = 0; i < 4; i++) {
if (guess.substring(i, i + 1).equals(stringnumber.substring(i, i + 1))) {
feedback.append("+");
} else if (stringnumber.contains(guess.substring(i, i + 1))) {
feedback.append("0");
} else {
feedback.append("X");
}
}
}
System.out.println(feedback.toString());
}
}
| hogeschoolnovi/backend-java-collecties-lussen | src/Bonus.java | 673 | /*
Vul hier de body van de methode in.
Stappenplan:
- Maak een nieuwe variabele van type Random. (Tip: Zoek op internet hoe je Random kunt gebruiken)
- Maak een nieuwe variabele van type HashSet.
- Schrijf een while-loop om 4 random nummers aan de hashset toe te voegen
- return de hashset
*/ | block_comment | nl | import java.util.HashSet;
import java.util.Objects;
import java.util.Scanner;
public class Bonus {
public static void main(String[] args) {
// Onderstaande code is uitgecommentarieerd. Haal de code uit de comment (delete /* en */) om aan de slag te gaan met de bonus
// In de code staan op verschillende plekken comments tussen "/*...*/" als hint wat je moet doen
HashSet<Integer> secretnumber = randomnumbergenerator();
String stringnumber = setToStringConverter(secretnumber);
System.out.println(stringnumber);
feedback(/*vul hier het juiste argument in*/);
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ randomnumbergenerator(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de<SUF>*/
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ setToStringConverter(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak als eerst een String variabele met als waarde een lege String. (of gebruik een StringBuilder)
- Schrijf vervolgens een for-loop om de items in de hashset een voor een aan de String variabele toe te voegen.
- Return de (gevulde) String variabele
*/
}
public static void/*moet dit "void" zijn of wat anders?*/ feedback(String stringnumber) {
Scanner scanner = new Scanner(System.in);
StringBuilder feedback = new StringBuilder();
System.out.println("+ = juiste nummer op de juiste plek, O = juiste nummer verkeerde plek, X = verkeerde nummer");
System.out.println("Doe een gok, Let op vul 4 getallen in.");
String guess = scanner.nextLine();
if (Objects.equals(guess, stringnumber)) {
System.out.println("gefeliciteerd je hebt het goed");
} else {
for (int i = 0; i < 4; i++) {
if (guess.substring(i, i + 1).equals(stringnumber.substring(i, i + 1))) {
feedback.append("+");
} else if (stringnumber.contains(guess.substring(i, i + 1))) {
feedback.append("0");
} else {
feedback.append("X");
}
}
}
System.out.println(feedback.toString());
}
}
|
1676_6 | import java.util.HashSet;
import java.util.Objects;
import java.util.Scanner;
public class Bonus {
public static void main(String[] args) {
// Onderstaande code is uitgecommentarieerd. Haal de code uit de comment (delete /* en */) om aan de slag te gaan met de bonus
// In de code staan op verschillende plekken comments tussen "/*...*/" als hint wat je moet doen
HashSet<Integer> secretnumber = randomnumbergenerator();
String stringnumber = setToStringConverter(secretnumber);
System.out.println(stringnumber);
feedback(/*vul hier het juiste argument in*/);
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ randomnumbergenerator(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak een nieuwe variabele van type Random. (Tip: Zoek op internet hoe je Random kunt gebruiken)
- Maak een nieuwe variabele van type HashSet.
- Schrijf een while-loop om 4 random nummers aan de hashset toe te voegen
- return de hashset
*/
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ setToStringConverter(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak als eerst een String variabele met als waarde een lege String. (of gebruik een StringBuilder)
- Schrijf vervolgens een for-loop om de items in de hashset een voor een aan de String variabele toe te voegen.
- Return de (gevulde) String variabele
*/
}
public static void/*moet dit "void" zijn of wat anders?*/ feedback(String stringnumber) {
Scanner scanner = new Scanner(System.in);
StringBuilder feedback = new StringBuilder();
System.out.println("+ = juiste nummer op de juiste plek, O = juiste nummer verkeerde plek, X = verkeerde nummer");
System.out.println("Doe een gok, Let op vul 4 getallen in.");
String guess = scanner.nextLine();
if (Objects.equals(guess, stringnumber)) {
System.out.println("gefeliciteerd je hebt het goed");
} else {
for (int i = 0; i < 4; i++) {
if (guess.substring(i, i + 1).equals(stringnumber.substring(i, i + 1))) {
feedback.append("+");
} else if (stringnumber.contains(guess.substring(i, i + 1))) {
feedback.append("0");
} else {
feedback.append("X");
}
}
}
System.out.println(feedback.toString());
}
}
| hogeschoolnovi/backend-java-collecties-lussen | src/Bonus.java | 673 | /*moet dit returntype "void" zijn of wat anders?*/ | block_comment | nl | import java.util.HashSet;
import java.util.Objects;
import java.util.Scanner;
public class Bonus {
public static void main(String[] args) {
// Onderstaande code is uitgecommentarieerd. Haal de code uit de comment (delete /* en */) om aan de slag te gaan met de bonus
// In de code staan op verschillende plekken comments tussen "/*...*/" als hint wat je moet doen
HashSet<Integer> secretnumber = randomnumbergenerator();
String stringnumber = setToStringConverter(secretnumber);
System.out.println(stringnumber);
feedback(/*vul hier het juiste argument in*/);
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ randomnumbergenerator(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak een nieuwe variabele van type Random. (Tip: Zoek op internet hoe je Random kunt gebruiken)
- Maak een nieuwe variabele van type HashSet.
- Schrijf een while-loop om 4 random nummers aan de hashset toe te voegen
- return de hashset
*/
}
public static void/*moet dit returntype<SUF>*/ setToStringConverter(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak als eerst een String variabele met als waarde een lege String. (of gebruik een StringBuilder)
- Schrijf vervolgens een for-loop om de items in de hashset een voor een aan de String variabele toe te voegen.
- Return de (gevulde) String variabele
*/
}
public static void/*moet dit "void" zijn of wat anders?*/ feedback(String stringnumber) {
Scanner scanner = new Scanner(System.in);
StringBuilder feedback = new StringBuilder();
System.out.println("+ = juiste nummer op de juiste plek, O = juiste nummer verkeerde plek, X = verkeerde nummer");
System.out.println("Doe een gok, Let op vul 4 getallen in.");
String guess = scanner.nextLine();
if (Objects.equals(guess, stringnumber)) {
System.out.println("gefeliciteerd je hebt het goed");
} else {
for (int i = 0; i < 4; i++) {
if (guess.substring(i, i + 1).equals(stringnumber.substring(i, i + 1))) {
feedback.append("+");
} else if (stringnumber.contains(guess.substring(i, i + 1))) {
feedback.append("0");
} else {
feedback.append("X");
}
}
}
System.out.println(feedback.toString());
}
}
|
1676_7 | import java.util.HashSet;
import java.util.Objects;
import java.util.Scanner;
public class Bonus {
public static void main(String[] args) {
// Onderstaande code is uitgecommentarieerd. Haal de code uit de comment (delete /* en */) om aan de slag te gaan met de bonus
// In de code staan op verschillende plekken comments tussen "/*...*/" als hint wat je moet doen
HashSet<Integer> secretnumber = randomnumbergenerator();
String stringnumber = setToStringConverter(secretnumber);
System.out.println(stringnumber);
feedback(/*vul hier het juiste argument in*/);
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ randomnumbergenerator(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak een nieuwe variabele van type Random. (Tip: Zoek op internet hoe je Random kunt gebruiken)
- Maak een nieuwe variabele van type HashSet.
- Schrijf een while-loop om 4 random nummers aan de hashset toe te voegen
- return de hashset
*/
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ setToStringConverter(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak als eerst een String variabele met als waarde een lege String. (of gebruik een StringBuilder)
- Schrijf vervolgens een for-loop om de items in de hashset een voor een aan de String variabele toe te voegen.
- Return de (gevulde) String variabele
*/
}
public static void/*moet dit "void" zijn of wat anders?*/ feedback(String stringnumber) {
Scanner scanner = new Scanner(System.in);
StringBuilder feedback = new StringBuilder();
System.out.println("+ = juiste nummer op de juiste plek, O = juiste nummer verkeerde plek, X = verkeerde nummer");
System.out.println("Doe een gok, Let op vul 4 getallen in.");
String guess = scanner.nextLine();
if (Objects.equals(guess, stringnumber)) {
System.out.println("gefeliciteerd je hebt het goed");
} else {
for (int i = 0; i < 4; i++) {
if (guess.substring(i, i + 1).equals(stringnumber.substring(i, i + 1))) {
feedback.append("+");
} else if (stringnumber.contains(guess.substring(i, i + 1))) {
feedback.append("0");
} else {
feedback.append("X");
}
}
}
System.out.println(feedback.toString());
}
}
| hogeschoolnovi/backend-java-collecties-lussen | src/Bonus.java | 673 | /*Heeft deze methode nog parameter(s) nodig?*/ | block_comment | nl | import java.util.HashSet;
import java.util.Objects;
import java.util.Scanner;
public class Bonus {
public static void main(String[] args) {
// Onderstaande code is uitgecommentarieerd. Haal de code uit de comment (delete /* en */) om aan de slag te gaan met de bonus
// In de code staan op verschillende plekken comments tussen "/*...*/" als hint wat je moet doen
HashSet<Integer> secretnumber = randomnumbergenerator();
String stringnumber = setToStringConverter(secretnumber);
System.out.println(stringnumber);
feedback(/*vul hier het juiste argument in*/);
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ randomnumbergenerator(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak een nieuwe variabele van type Random. (Tip: Zoek op internet hoe je Random kunt gebruiken)
- Maak een nieuwe variabele van type HashSet.
- Schrijf een while-loop om 4 random nummers aan de hashset toe te voegen
- return de hashset
*/
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ setToStringConverter(/*Heeft deze methode<SUF>*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak als eerst een String variabele met als waarde een lege String. (of gebruik een StringBuilder)
- Schrijf vervolgens een for-loop om de items in de hashset een voor een aan de String variabele toe te voegen.
- Return de (gevulde) String variabele
*/
}
public static void/*moet dit "void" zijn of wat anders?*/ feedback(String stringnumber) {
Scanner scanner = new Scanner(System.in);
StringBuilder feedback = new StringBuilder();
System.out.println("+ = juiste nummer op de juiste plek, O = juiste nummer verkeerde plek, X = verkeerde nummer");
System.out.println("Doe een gok, Let op vul 4 getallen in.");
String guess = scanner.nextLine();
if (Objects.equals(guess, stringnumber)) {
System.out.println("gefeliciteerd je hebt het goed");
} else {
for (int i = 0; i < 4; i++) {
if (guess.substring(i, i + 1).equals(stringnumber.substring(i, i + 1))) {
feedback.append("+");
} else if (stringnumber.contains(guess.substring(i, i + 1))) {
feedback.append("0");
} else {
feedback.append("X");
}
}
}
System.out.println(feedback.toString());
}
}
|
1676_8 | import java.util.HashSet;
import java.util.Objects;
import java.util.Scanner;
public class Bonus {
public static void main(String[] args) {
// Onderstaande code is uitgecommentarieerd. Haal de code uit de comment (delete /* en */) om aan de slag te gaan met de bonus
// In de code staan op verschillende plekken comments tussen "/*...*/" als hint wat je moet doen
HashSet<Integer> secretnumber = randomnumbergenerator();
String stringnumber = setToStringConverter(secretnumber);
System.out.println(stringnumber);
feedback(/*vul hier het juiste argument in*/);
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ randomnumbergenerator(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak een nieuwe variabele van type Random. (Tip: Zoek op internet hoe je Random kunt gebruiken)
- Maak een nieuwe variabele van type HashSet.
- Schrijf een while-loop om 4 random nummers aan de hashset toe te voegen
- return de hashset
*/
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ setToStringConverter(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak als eerst een String variabele met als waarde een lege String. (of gebruik een StringBuilder)
- Schrijf vervolgens een for-loop om de items in de hashset een voor een aan de String variabele toe te voegen.
- Return de (gevulde) String variabele
*/
}
public static void/*moet dit "void" zijn of wat anders?*/ feedback(String stringnumber) {
Scanner scanner = new Scanner(System.in);
StringBuilder feedback = new StringBuilder();
System.out.println("+ = juiste nummer op de juiste plek, O = juiste nummer verkeerde plek, X = verkeerde nummer");
System.out.println("Doe een gok, Let op vul 4 getallen in.");
String guess = scanner.nextLine();
if (Objects.equals(guess, stringnumber)) {
System.out.println("gefeliciteerd je hebt het goed");
} else {
for (int i = 0; i < 4; i++) {
if (guess.substring(i, i + 1).equals(stringnumber.substring(i, i + 1))) {
feedback.append("+");
} else if (stringnumber.contains(guess.substring(i, i + 1))) {
feedback.append("0");
} else {
feedback.append("X");
}
}
}
System.out.println(feedback.toString());
}
}
| hogeschoolnovi/backend-java-collecties-lussen | src/Bonus.java | 673 | /*
Vul hier de body van de methode in.
Stappenplan:
- Maak als eerst een String variabele met als waarde een lege String. (of gebruik een StringBuilder)
- Schrijf vervolgens een for-loop om de items in de hashset een voor een aan de String variabele toe te voegen.
- Return de (gevulde) String variabele
*/ | block_comment | nl | import java.util.HashSet;
import java.util.Objects;
import java.util.Scanner;
public class Bonus {
public static void main(String[] args) {
// Onderstaande code is uitgecommentarieerd. Haal de code uit de comment (delete /* en */) om aan de slag te gaan met de bonus
// In de code staan op verschillende plekken comments tussen "/*...*/" als hint wat je moet doen
HashSet<Integer> secretnumber = randomnumbergenerator();
String stringnumber = setToStringConverter(secretnumber);
System.out.println(stringnumber);
feedback(/*vul hier het juiste argument in*/);
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ randomnumbergenerator(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak een nieuwe variabele van type Random. (Tip: Zoek op internet hoe je Random kunt gebruiken)
- Maak een nieuwe variabele van type HashSet.
- Schrijf een while-loop om 4 random nummers aan de hashset toe te voegen
- return de hashset
*/
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ setToStringConverter(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de<SUF>*/
}
public static void/*moet dit "void" zijn of wat anders?*/ feedback(String stringnumber) {
Scanner scanner = new Scanner(System.in);
StringBuilder feedback = new StringBuilder();
System.out.println("+ = juiste nummer op de juiste plek, O = juiste nummer verkeerde plek, X = verkeerde nummer");
System.out.println("Doe een gok, Let op vul 4 getallen in.");
String guess = scanner.nextLine();
if (Objects.equals(guess, stringnumber)) {
System.out.println("gefeliciteerd je hebt het goed");
} else {
for (int i = 0; i < 4; i++) {
if (guess.substring(i, i + 1).equals(stringnumber.substring(i, i + 1))) {
feedback.append("+");
} else if (stringnumber.contains(guess.substring(i, i + 1))) {
feedback.append("0");
} else {
feedback.append("X");
}
}
}
System.out.println(feedback.toString());
}
}
|
1676_9 | import java.util.HashSet;
import java.util.Objects;
import java.util.Scanner;
public class Bonus {
public static void main(String[] args) {
// Onderstaande code is uitgecommentarieerd. Haal de code uit de comment (delete /* en */) om aan de slag te gaan met de bonus
// In de code staan op verschillende plekken comments tussen "/*...*/" als hint wat je moet doen
HashSet<Integer> secretnumber = randomnumbergenerator();
String stringnumber = setToStringConverter(secretnumber);
System.out.println(stringnumber);
feedback(/*vul hier het juiste argument in*/);
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ randomnumbergenerator(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak een nieuwe variabele van type Random. (Tip: Zoek op internet hoe je Random kunt gebruiken)
- Maak een nieuwe variabele van type HashSet.
- Schrijf een while-loop om 4 random nummers aan de hashset toe te voegen
- return de hashset
*/
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ setToStringConverter(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak als eerst een String variabele met als waarde een lege String. (of gebruik een StringBuilder)
- Schrijf vervolgens een for-loop om de items in de hashset een voor een aan de String variabele toe te voegen.
- Return de (gevulde) String variabele
*/
}
public static void/*moet dit "void" zijn of wat anders?*/ feedback(String stringnumber) {
Scanner scanner = new Scanner(System.in);
StringBuilder feedback = new StringBuilder();
System.out.println("+ = juiste nummer op de juiste plek, O = juiste nummer verkeerde plek, X = verkeerde nummer");
System.out.println("Doe een gok, Let op vul 4 getallen in.");
String guess = scanner.nextLine();
if (Objects.equals(guess, stringnumber)) {
System.out.println("gefeliciteerd je hebt het goed");
} else {
for (int i = 0; i < 4; i++) {
if (guess.substring(i, i + 1).equals(stringnumber.substring(i, i + 1))) {
feedback.append("+");
} else if (stringnumber.contains(guess.substring(i, i + 1))) {
feedback.append("0");
} else {
feedback.append("X");
}
}
}
System.out.println(feedback.toString());
}
}
| hogeschoolnovi/backend-java-collecties-lussen | src/Bonus.java | 673 | /*moet dit "void" zijn of wat anders?*/ | block_comment | nl | import java.util.HashSet;
import java.util.Objects;
import java.util.Scanner;
public class Bonus {
public static void main(String[] args) {
// Onderstaande code is uitgecommentarieerd. Haal de code uit de comment (delete /* en */) om aan de slag te gaan met de bonus
// In de code staan op verschillende plekken comments tussen "/*...*/" als hint wat je moet doen
HashSet<Integer> secretnumber = randomnumbergenerator();
String stringnumber = setToStringConverter(secretnumber);
System.out.println(stringnumber);
feedback(/*vul hier het juiste argument in*/);
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ randomnumbergenerator(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak een nieuwe variabele van type Random. (Tip: Zoek op internet hoe je Random kunt gebruiken)
- Maak een nieuwe variabele van type HashSet.
- Schrijf een while-loop om 4 random nummers aan de hashset toe te voegen
- return de hashset
*/
}
public static void/*moet dit returntype "void" zijn of wat anders?*/ setToStringConverter(/*Heeft deze methode nog parameter(s) nodig?*/){
/*
Vul hier de body van de methode in.
Stappenplan:
- Maak als eerst een String variabele met als waarde een lege String. (of gebruik een StringBuilder)
- Schrijf vervolgens een for-loop om de items in de hashset een voor een aan de String variabele toe te voegen.
- Return de (gevulde) String variabele
*/
}
public static void/*moet dit "void"<SUF>*/ feedback(String stringnumber) {
Scanner scanner = new Scanner(System.in);
StringBuilder feedback = new StringBuilder();
System.out.println("+ = juiste nummer op de juiste plek, O = juiste nummer verkeerde plek, X = verkeerde nummer");
System.out.println("Doe een gok, Let op vul 4 getallen in.");
String guess = scanner.nextLine();
if (Objects.equals(guess, stringnumber)) {
System.out.println("gefeliciteerd je hebt het goed");
} else {
for (int i = 0; i < 4; i++) {
if (guess.substring(i, i + 1).equals(stringnumber.substring(i, i + 1))) {
feedback.append("+");
} else if (stringnumber.contains(guess.substring(i, i + 1))) {
feedback.append("0");
} else {
feedback.append("X");
}
}
}
System.out.println(feedback.toString());
}
}
|
1682_1 | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
| topicusonderwijs/tribe-krd-opensource | cobra/commons/src/main/java/nl/topicus/cobra/validation/ElfProef.java | 1,884 | /**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/ | block_comment | nl | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor<SUF>*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
|
1682_2 | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
| topicusonderwijs/tribe-krd-opensource | cobra/commons/src/main/java/nl/topicus/cobra/validation/ElfProef.java | 1,884 | /**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/ | block_comment | nl | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de<SUF>*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
|
1682_3 | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
| topicusonderwijs/tribe-krd-opensource | cobra/commons/src/main/java/nl/topicus/cobra/validation/ElfProef.java | 1,884 | /**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/ | block_comment | nl | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de<SUF>*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
|
1682_4 | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
| topicusonderwijs/tribe-krd-opensource | cobra/commons/src/main/java/nl/topicus/cobra/validation/ElfProef.java | 1,884 | /**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/ | block_comment | nl | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van<SUF>*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
|
1682_5 | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
| topicusonderwijs/tribe-krd-opensource | cobra/commons/src/main/java/nl/topicus/cobra/validation/ElfProef.java | 1,884 | /**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/ | block_comment | nl | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het<SUF>*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
|
1682_6 | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
| topicusonderwijs/tribe-krd-opensource | cobra/commons/src/main/java/nl/topicus/cobra/validation/ElfProef.java | 1,884 | // daadwerkelijke controle op een number via snelle controle | line_comment | nl | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle<SUF>
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
|
1682_7 | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
| topicusonderwijs/tribe-krd-opensource | cobra/commons/src/main/java/nl/topicus/cobra/validation/ElfProef.java | 1,884 | /**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/ | block_comment | nl | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het<SUF>*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
|
1682_8 | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
| topicusonderwijs/tribe-krd-opensource | cobra/commons/src/main/java/nl/topicus/cobra/validation/ElfProef.java | 1,884 | /**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/ | block_comment | nl | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het<SUF>*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
|
1682_9 | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
| topicusonderwijs/tribe-krd-opensource | cobra/commons/src/main/java/nl/topicus/cobra/validation/ElfProef.java | 1,884 | /**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/ | block_comment | nl | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het<SUF>*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
|
1682_10 | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
| topicusonderwijs/tribe-krd-opensource | cobra/commons/src/main/java/nl/topicus/cobra/validation/ElfProef.java | 1,884 | /**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/ | block_comment | nl | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het<SUF>*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
|
1682_11 | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
| topicusonderwijs/tribe-krd-opensource | cobra/commons/src/main/java/nl/topicus/cobra/validation/ElfProef.java | 1,884 | // daadwerkelijke controle op een number via snelle controle | line_comment | nl | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle<SUF>
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
|
1682_12 | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
| topicusonderwijs/tribe-krd-opensource | cobra/commons/src/main/java/nl/topicus/cobra/validation/ElfProef.java | 1,884 | /**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/ | block_comment | nl | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het<SUF>*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
|
1682_13 | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
| topicusonderwijs/tribe-krd-opensource | cobra/commons/src/main/java/nl/topicus/cobra/validation/ElfProef.java | 1,884 | /**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/ | block_comment | nl | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de<SUF>*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
|
1682_14 | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
| topicusonderwijs/tribe-krd-opensource | cobra/commons/src/main/java/nl/topicus/cobra/validation/ElfProef.java | 1,884 | /**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/ | block_comment | nl | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de<SUF>*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
|
1682_15 | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
| topicusonderwijs/tribe-krd-opensource | cobra/commons/src/main/java/nl/topicus/cobra/validation/ElfProef.java | 1,884 | /**
* Converteert de string nummer naar een array van longs met een lengte van 9 bedoelt
* voor bewerking in een elf-proef berekening. Voorbeeld "123456789" wordt
* [1,2,3,4,5,6,7,8,9], en "12" wordt [0,0,0,0,0,0,0,1,2].
*
* @param nummer
* het getal dat vertaald moet worden.
* @return een array van de
*/ | block_comment | nl | /*
* Copyright (c) 2005-2007, Topicus b.v.
* All rights reserved
*/
package nl.topicus.cobra.validation;
/**
* Elfproef klasse voor het uitvoeren van elfproef checks op bankrekeningnummers en
* sofinummers. De elfproef is een invoercontrole op rekeningnummers en sofinummers
* waarmee een fout in een cijfer van het nummer kan worden opgespoord.
* <p>
* De berekening gebeurt door elk cijfer te vermenigvuldigen met een factor en de
* resultaten bij elkaar op te tellen. De som moet dan modulo elf gelijk zijn aan nul.
* <p>
* Bij onderwijsnummers moet de som modulo elf gelijk zijn aan 5.
*
* @author Martijn Dashorst
* @author Laurens Hop
*/
public final class ElfProef
{
/**
* Lijst van de multipliers voor elke digit in een sofinummer of onderwijsnummer. Let
* op de laatste multiplier, die is negatief. Bij een onderwijsnummer moet de som
* modulo elf gelijk zijn aan 5, bij een sofinummer aan 0.
*/
private static final long[] SOFI_ONDNR_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, -1};
/**
* Lijst van de multipliers voor elke digit in een bank rekeningnummer.
*/
private static final long[] REKN_MULTIPLIERS = {9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* Vereiste uitkomst van de som modulo elf in het geval van een onderwijsnummer.
*/
private static final long ONDNR_UITKOMST = 5;
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(String sofinummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(sofinummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(sofinummer), SOFI_ONDNR_MULTIPLIERS);
}
/**
* Bepaalt of het sofinummer voldoet aan de sofinummer elfproef.
*
* @param sofinummer
* het sofinummer dat gecontroleerd moet worden.
* @return <code>true</code> als het sofinummer voldoet aan de elf proef.
*/
public boolean isGeldigSofiNummer(Long sofinummer)
{
return isGeldigSofiNummer(sofinummer.toString());
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(String rekeningnummer)
{
return isElfProef(getDigits(rekeningnummer), REKN_MULTIPLIERS);
}
/**
* Bepaalt of het rekeningnummer voldoet aan de rekeningnummer elfproef.
*
* @param rekeningnummer
* het rekeningnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het rekeningnummer voldoet aan de elf proef.
*/
public boolean isGeldigRekeningNummer(Long rekeningnummer)
{
return isGeldigRekeningNummer(rekeningnummer.toString());
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(String onderwijsnummer)
{
// daadwerkelijke controle op een number via snelle controle
try
{
Long.valueOf(onderwijsnummer);
}
catch (NumberFormatException e)
{
return false;
}
return isElfProef(getDigits(onderwijsnummer), SOFI_ONDNR_MULTIPLIERS, ONDNR_UITKOMST);
}
/**
* Bepaalt of het onderwijsnummer voldoet aan de onderwijsnummer elfproef.
*
* @param onderwijsnummer
* het onderwijsnummer dat gecontroleerd moet worden.
* @return <code>true</code> als het onderwijsnummer voldoet aan de elf proef.
*/
public boolean isGeldigOnderwijsNummer(Long onderwijsnummer)
{
return isGeldigOnderwijsNummer(onderwijsnummer.toString());
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan 0. Deze methode kan dus generiek met rekeningnummers en
* sofinummers overweg, gegeven de juiste invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf 0 is.
*/
private boolean isElfProef(long[] digits, long[] multipliers)
{
return isElfProef(digits, multipliers, 0);
}
/**
* Bepaalt of de som van elke digit vermenigvuldigd met zijn bijbehorende multiplier
* modulo elf gelijk is aan een zekere uitkomst. Deze methode kan dus generiek met
* rekeningnummers, sofinummers en onderwijsnummers overweg, gegeven de juiste
* invulling van de multipliers.
*
* @param digits
* het nummer dat elf proef moet zijn
* @param multipliers
* de vermenigvuldigings factoren
* @param uitkomst
* de vereiste uitkomst
* @return <code>true</code> als de som van elk digit vermenigvuldigd met multiplier
* modulo elf gelijk is aan de vereiste uitkomst is.
*/
private boolean isElfProef(long[] digits, long[] multipliers, long uitkomst)
{
long sum = 0;
for (int i = 0; i < multipliers.length; i++)
{
sum += digits[i] * multipliers[i];
}
return sum % 11 == uitkomst;
}
/**
* Converteert de string<SUF>*/
long[] getDigits(String nummer)
{
long[] digits = new long[9];
for (int i = nummer.length() - 1, j = 1; i >= 0; i--, j++)
{
digits[digits.length - j] = Character.getNumericValue(nummer.charAt(i));
}
return digits;
}
}
|
1684_2 | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== | EliasDeHondt/Memo-Race | TODO.java | 949 | // TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven. | line_comment | nl | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: -<SUF>
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== |
1684_3 | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== | EliasDeHondt/Memo-Race | TODO.java | 949 | // - Elke speler kan een avatar kiezen of zelf een foto toevoegen. | line_comment | nl | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke<SUF>
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== |
1684_4 | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== | EliasDeHondt/Memo-Race | TODO.java | 949 | // - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand. | line_comment | nl | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie<SUF>
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== |
1684_5 | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== | EliasDeHondt/Memo-Race | TODO.java | 949 | // - Zorg voor een mooi grafische vormgeving. | line_comment | nl | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg<SUF>
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== |
1684_6 | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== | EliasDeHondt/Memo-Race | TODO.java | 949 | // - Tijdens het spelverloop moet volgende zichtbaar zijn: | line_comment | nl | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens<SUF>
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== |
1684_7 | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== | EliasDeHondt/Memo-Race | TODO.java | 949 | // - Een dobbelsteen. | line_comment | nl | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een<SUF>
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== |
1684_8 | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== | EliasDeHondt/Memo-Race | TODO.java | 949 | // - Het speelveld met in het midden de omgedraaide kaarten. | line_comment | nl | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het<SUF>
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== |
1684_9 | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== | EliasDeHondt/Memo-Race | TODO.java | 949 | // - Per speler zijn naam, de avatar en de gewonnen kaarten. | line_comment | nl | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per<SUF>
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== |
1684_10 | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== | EliasDeHondt/Memo-Race | TODO.java | 949 | // - Een pion die automatisch verplaatst na een worp. | line_comment | nl | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een<SUF>
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== |
1684_11 | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== | EliasDeHondt/Memo-Race | TODO.java | 949 | // - Kaarten moeten met de muis omgedraaid kunnen worden. | line_comment | nl | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten<SUF>
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== |
1684_12 | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== | EliasDeHondt/Memo-Race | TODO.java | 949 | // - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak | line_comment | nl | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als<SUF>
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== |
1684_13 | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== | EliasDeHondt/Memo-Race | TODO.java | 949 | // (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan. | line_comment | nl | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder)<SUF>
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== |
1684_14 | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== | EliasDeHondt/Memo-Race | TODO.java | 949 | // - Maak visueel zichtbaar welke speler aan de beurt is. | line_comment | nl | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak<SUF>
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== |
1684_15 | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== | EliasDeHondt/Memo-Race | TODO.java | 949 | /*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/ | block_comment | nl | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een<SUF>*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== |
1684_16 | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/
// ===================================================================================================================== | EliasDeHondt/Memo-Race | TODO.java | 949 | /*
* Er wordt om de beurt gespeeld. Het spel beslist random in welke
* volgorde de spelers mogen spelen. De pion start op “go”. De eerste
* speler werpt de dobbelsteen en zet de pion evenveel vakken (groene
* genummerd in de afbeelding) vooruit. Elk vak toont een afbeelding.
* Het is de bedoeling dat de speler de kaart met dezelfde afbeelding
* omdraait (kaarten zijn de witte vakjes in de afbeelding). Als dat lukt,
* dan krijgt hij de kaart. In het andere geval wordt de kaart terug
* omgedraaid. Hierna is de beurt van deze speler om en is het aan de
* volgende speler. Hij gooit en verplaatst de pion. Ook hij moet proberen
* die kaart om te draaien die overeenkomt met de afbeelding van het
* vak waar de pion nu op staat. Het spel loopt zo verder tot alle kaarten van het veld verdwenen
* zijn. De persoon met de meeste kaarten wint het spel. De pion slaat de vakken met reeds
* gevonden figuren en de hoekvakken over.
*/ | block_comment | nl | /**
* @author Vera Wise
* @author Elias De Hondt
* @since 08/12/2022
*/
// =====================================================================================================================
/*
* Canvas KdG
* @see https://canvas.kdg.be/courses/37158/pages/afspraken-en-deadlines?module_item_id=663060
*
* Github
* @see https://github.com/EliasDeHondt/Memo-Race
*
* Google Docs
* @see https://docs.google.com/spreadsheets/d/199y9TW0weDEmgGD8Iv0UWyqQnMW8zF_RrBZ8XB4lQBc/edit#gid=0
*
*/
// =====================================================================================================================
// TODO: - Voorzie een startscherm waar je de namen van de spelers kan ingeven.
// - Elke speler kan een avatar kiezen of zelf een foto toevoegen.
// - Voorzie een lijst op het scherm met eerder aangemaakte spelers. Sla deze op in een bestand.
// - Zorg voor een mooi grafische vormgeving.
// - Tijdens het spelverloop moet volgende zichtbaar zijn:
// - Een dobbelsteen.
// - Het speelveld met in het midden de omgedraaide kaarten.
// - Per speler zijn naam, de avatar en de gewonnen kaarten.
// - Een pion die automatisch verplaatst na een worp.
// - Kaarten moeten met de muis omgedraaid kunnen worden.
// - Als een figuur gevonden is moet het overeenkomstige vak een alternatieve opmaak
// (bv. donkerder) krijgen zodat duidelijk is dat de pion deze vakken mag overslaan.
// - Maak visueel zichtbaar welke speler aan de beurt is.
// =====================================================================================================================
// SPELBESCHRIJVING
/*
* MemoRace is een variant op memory, maar een dobbelsteen zorgt voor een extra dimensie. Het
* spel leert kinderen dezelfde vaardigheden als Memory en de dobbelsteen bevorderd het tellen.
* Een pion loopt op een pad met in elk vak een verschillende afbeelding rond een speelveld. In het
* speelveld liggen omgedraaide kaarten met de verschillende afbeeldingen. De spelers moeten
* zoveel mogelijk van de afbeeldingen op het pad terugvinden bij de omgedraaide kaarten in het
* midden van het speelveld. De speler die op het einde de meeste kaarten gevonden heeft wint
* het spel. Het kan gespeeld worden met 2 tot 6 spelers
* Hieronder een overzicht van de belangrijkste spelonderdelen:
* • een spelbord
* • 16 kaarten die willekeurig in het midden van het spelbord gelegd worden
* • 1 dobbelsteen
* • 1 pion
*/
// =====================================================================================================================
// SPELVERLOOP
/*
* Er wordt om<SUF>*/
// ===================================================================================================================== |
1686_0 | import Database.Data.DrinksTable;
import Views.OrderView;
import javafx.application.Application;
import javafx.stage.Stage;
/**
* Deze klasse word gebruikt om de applicatie zelf op te zetten.
*/
public class Main extends Application {
@Override
/**
* De start methode word gebruikt om alle interfaces benodigd op te starten.
* Daarnaast zorgt deze methode ervoor dat alle dependendies die globaal zijn hier opgestart worden.
*/
public void start(Stage primaryStage) {
try {
System.out.println("Booting application.");
// Zet een nieuw 'OrderView' object op en render deze.
OrderView currentOrderView = new OrderView(primaryStage);
currentOrderView.Render();
currentOrderView.SetupCallbacks();
DrinksTable tableCreation = new DrinksTable();
tableCreation.Create();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* Deze functie start de complete applicatie op.
* @param args CLI Argumenten
*/
public static void main(String[] args) {
launch(args);
}
} | RikkertTheDeveloper/Java-Structure-Template | Main.java | 272 | /**
* Deze klasse word gebruikt om de applicatie zelf op te zetten.
*/ | block_comment | nl | import Database.Data.DrinksTable;
import Views.OrderView;
import javafx.application.Application;
import javafx.stage.Stage;
/**
* Deze klasse word<SUF>*/
public class Main extends Application {
@Override
/**
* De start methode word gebruikt om alle interfaces benodigd op te starten.
* Daarnaast zorgt deze methode ervoor dat alle dependendies die globaal zijn hier opgestart worden.
*/
public void start(Stage primaryStage) {
try {
System.out.println("Booting application.");
// Zet een nieuw 'OrderView' object op en render deze.
OrderView currentOrderView = new OrderView(primaryStage);
currentOrderView.Render();
currentOrderView.SetupCallbacks();
DrinksTable tableCreation = new DrinksTable();
tableCreation.Create();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* Deze functie start de complete applicatie op.
* @param args CLI Argumenten
*/
public static void main(String[] args) {
launch(args);
}
} |
1686_1 | import Database.Data.DrinksTable;
import Views.OrderView;
import javafx.application.Application;
import javafx.stage.Stage;
/**
* Deze klasse word gebruikt om de applicatie zelf op te zetten.
*/
public class Main extends Application {
@Override
/**
* De start methode word gebruikt om alle interfaces benodigd op te starten.
* Daarnaast zorgt deze methode ervoor dat alle dependendies die globaal zijn hier opgestart worden.
*/
public void start(Stage primaryStage) {
try {
System.out.println("Booting application.");
// Zet een nieuw 'OrderView' object op en render deze.
OrderView currentOrderView = new OrderView(primaryStage);
currentOrderView.Render();
currentOrderView.SetupCallbacks();
DrinksTable tableCreation = new DrinksTable();
tableCreation.Create();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* Deze functie start de complete applicatie op.
* @param args CLI Argumenten
*/
public static void main(String[] args) {
launch(args);
}
} | RikkertTheDeveloper/Java-Structure-Template | Main.java | 272 | /**
* De start methode word gebruikt om alle interfaces benodigd op te starten.
* Daarnaast zorgt deze methode ervoor dat alle dependendies die globaal zijn hier opgestart worden.
*/ | block_comment | nl | import Database.Data.DrinksTable;
import Views.OrderView;
import javafx.application.Application;
import javafx.stage.Stage;
/**
* Deze klasse word gebruikt om de applicatie zelf op te zetten.
*/
public class Main extends Application {
@Override
/**
* De start methode<SUF>*/
public void start(Stage primaryStage) {
try {
System.out.println("Booting application.");
// Zet een nieuw 'OrderView' object op en render deze.
OrderView currentOrderView = new OrderView(primaryStage);
currentOrderView.Render();
currentOrderView.SetupCallbacks();
DrinksTable tableCreation = new DrinksTable();
tableCreation.Create();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* Deze functie start de complete applicatie op.
* @param args CLI Argumenten
*/
public static void main(String[] args) {
launch(args);
}
} |
1686_2 | import Database.Data.DrinksTable;
import Views.OrderView;
import javafx.application.Application;
import javafx.stage.Stage;
/**
* Deze klasse word gebruikt om de applicatie zelf op te zetten.
*/
public class Main extends Application {
@Override
/**
* De start methode word gebruikt om alle interfaces benodigd op te starten.
* Daarnaast zorgt deze methode ervoor dat alle dependendies die globaal zijn hier opgestart worden.
*/
public void start(Stage primaryStage) {
try {
System.out.println("Booting application.");
// Zet een nieuw 'OrderView' object op en render deze.
OrderView currentOrderView = new OrderView(primaryStage);
currentOrderView.Render();
currentOrderView.SetupCallbacks();
DrinksTable tableCreation = new DrinksTable();
tableCreation.Create();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* Deze functie start de complete applicatie op.
* @param args CLI Argumenten
*/
public static void main(String[] args) {
launch(args);
}
} | RikkertTheDeveloper/Java-Structure-Template | Main.java | 272 | // Zet een nieuw 'OrderView' object op en render deze. | line_comment | nl | import Database.Data.DrinksTable;
import Views.OrderView;
import javafx.application.Application;
import javafx.stage.Stage;
/**
* Deze klasse word gebruikt om de applicatie zelf op te zetten.
*/
public class Main extends Application {
@Override
/**
* De start methode word gebruikt om alle interfaces benodigd op te starten.
* Daarnaast zorgt deze methode ervoor dat alle dependendies die globaal zijn hier opgestart worden.
*/
public void start(Stage primaryStage) {
try {
System.out.println("Booting application.");
// Zet een<SUF>
OrderView currentOrderView = new OrderView(primaryStage);
currentOrderView.Render();
currentOrderView.SetupCallbacks();
DrinksTable tableCreation = new DrinksTable();
tableCreation.Create();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* Deze functie start de complete applicatie op.
* @param args CLI Argumenten
*/
public static void main(String[] args) {
launch(args);
}
} |
1687_0 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | /**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/ | block_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een<SUF>*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_2 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | /**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/ | block_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle<SUF>*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_4 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | /** kleur = de speler die de zet 'nu' moet doen */ | block_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de<SUF>*/
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_5 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | /** kleur = de speler die de laatste zet heeft gezet */ | block_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de<SUF>*/
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_7 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | /** hoeveel stappen deze node vooruit moet denken dmv recursie */ | block_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze<SUF>*/
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_8 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // de zetten die de tegenstander verplicht moet doen! | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten<SUF>
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_9 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // verplichte zetten, waardoor er maar 1 mogelijkheid is | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten,<SUF>
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_11 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // omdat er anders niet gewonnen wordt | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er<SUF>
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_12 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // er zijn meerdere verplichte zetten voor de andere | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn<SUF>
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_14 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // alleen die win kansen zijn initialiseren | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die<SUF>
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_15 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // we laten de waarde van stappenVooruit niet 1 afnemen | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten<SUF>
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_16 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // zoals normaal, omdat het hier maar een klein aantal | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal,<SUF>
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_17 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // de beste van de verplichte zetten zoeken... | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste<SUF>
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_18 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // de rest 'verwijderen' | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest<SUF>
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_20 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // uit hoeveel getallen ratingGem het gemiddelde is genomen | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel<SUF>
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_21 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // 'ik' heeft een rij :). De rating is positief | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft<SUF>
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_22 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // de oude grootte van de array maar ook de index van het nieuwe | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude<SUF>
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_23 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | /**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/ | block_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet<SUF>*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_24 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // het bord is in deze kolom vol | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord<SUF>
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_25 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit="); | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" +<SUF>
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_26 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // (waarschijnlijk) de eerste keer | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de<SUF>
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_27 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // de zet kan nu niet op het bord worden gemaakt, dus | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet<SUF>
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_29 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // luistert naar zetten van de tegenstander | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar<SUF>
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_30 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // [0][0] = links onderin, [5][6] = rechts bovenin | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] =<SUF>
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_31 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // soms hebben we gewoon niets te zeggen | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben<SUF>
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_32 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // Ik mag beginnen. We doen het midden, dat is het chillst | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag<SUF>
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_33 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // System.err.println(mijnZet + 1); | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet +<SUF>
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_35 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // wie de bal kaatst, kan hem terug verwachten ;) | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de<SUF>
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_36 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // een getal tussen de 1 en de 7 die de tegenstander heeft | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal<SUF>
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_37 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // System.err.println("tijd bezig: " + tijdBeginZet); | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig:<SUF>
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1687_39 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: " + tijdBezig);
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} | ludopulles/science-maker-codecup-demo | Ludiquatre.java | 4,582 | // System.err.println("tijd: " + tijdBezig); | line_comment | nl | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
* Versie van een vier-op-een-rij computertegenstander
*
* @author Ludo Pulles
*/
public class Ludiquatre {
private static MinimaxNode huidigeNode;
private static boolean isWit = false;
private static final int BREEDTE = 7, HOOGTE = 6;
/** de kleuren die in het bord komen. */
private static final byte LEEG = 0, IK = 1, HIJ = 2;
/**
* Dit zijn alle mogelijkheden dat er vier-op-een-rij kan voorkomen.
* {@link DIAGONAAL45} gaat van linksonder naar rechtsboven,
* {@link DIAGONAAL135} gaat van linksboven naar rechtsonder
*/
private static final int HORIZONTAAL = 0, VERTICAAL = 1, DIAGONAAL45 = 2,
DIAGONAAL135 = 3;
/** {@link Integer#MAX_VALUE} = 2.147.483.648 */
private static final int[] RATINGS = new int[] { 1, 100, 10000, 1000000 };
private static class MinimaxNode {
private byte kleur;
private byte[][] bord;
private Rating rating;
private MinimaxNode[] nodes = null;
/** kleur = de speler die de zet 'nu' moet doen */
private MinimaxNode(byte[][] oudBord, byte kleur, int kolom,
int stappenVooruit) throws IllegalStateException {
this(doeZet(oudBord, kleur, kolom), kleur, stappenVooruit);
}
/** kleur = de speler die de laatste zet heeft gezet */
private MinimaxNode(byte[][] bord, byte kleur, int stappenVooruit) {
this.bord = bord;
this.kleur = kleur;
this.rating = new Rating(bord);
denkVooruit(stappenVooruit);
}
private byte getNodeKleur() {
return kleur == IK ? HIJ : (kleur == HIJ ? IK : LEEG);
}
/** dit kiest de node met de hoogste rating */
private int besteZet(boolean ik) {
if (nodes == null) {
return -1;
}
float hoogsteRating = 0;
int index = -1;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
float rating = nodes[i].rating.rating;
if (index == -1
|| (ik ? rating > hoogsteRating
: rating < hoogsteRating)) {
hoogsteRating = rating;
index = i;
}
}
}
return index;
}
/** hoeveel stappen deze node vooruit moet denken dmv recursie */
private void denkVooruit(int stappenVooruit) {
byte nodeKleur = getNodeKleur();
if (stappenVooruit > 0 && rating.winnaar == LEEG) {
// de zetten die de tegenstander verplicht moet doen!
if (rating.winKansen != null && rating.winKansen.length > 0) {
int[] winKansen = rating.winKansen;
// verplichte zetten, waardoor er maar 1 mogelijkheid is
// voor de nodes, omdat die stap wel moet worden ondernomen,
// omdat er anders niet gewonnen wordt
// er zijn meerdere verplichte zetten voor de andere
// reset de nodes
this.nodes = new MinimaxNode[7];
for (int i = 0; i < winKansen.length; i++) {
// alleen die win kansen zijn initialiseren
// we laten de waarde van stappenVooruit niet 1 afnemen
// zoals normaal, omdat het hier maar een klein aantal
// nodes bevat.
this.nodes[winKansen[i]] = new MinimaxNode(bord,
nodeKleur, winKansen[i], stappenVooruit);
}
// de beste van de verplichte zetten zoeken...
if (winKansen.length == 1) {
this.rating = this.nodes[winKansen[0]].rating;
} else {
int besteZet = besteZet(nodeKleur == IK);
for (int i = 0; i < winKansen.length; i++) {
if (winKansen[i] != besteZet) {
// de rest 'verwijderen'
this.nodes[winKansen[i]] = null;
}
}
this.rating = this.nodes[besteZet].rating;
}
} else {
this.nodes = new MinimaxNode[BREEDTE];
for (int i = 0; i < BREEDTE; i++) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i,
stappenVooruit - 1);
} catch (IllegalStateException e) {
}
}
this.rating = new Rating(nodes);
}
}
}
private MinimaxNode initNode(int index) {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
if (nodes[index] == null) {
try {
nodes[index] = new MinimaxNode(bord, nodeKleur, index, 0);
} catch (IllegalStateException e) {
}
}
return nodes[index];
}
private void initNodes() {
if (nodes == null) {
nodes = new MinimaxNode[BREEDTE];
}
byte nodeKleur = getNodeKleur();
for (int i = 0; i < BREEDTE; i++) {
if (nodes[i] == null) {
try {
nodes[i] = new MinimaxNode(bord, nodeKleur, i, 0);
} catch (IllegalStateException e) {
}
}
}
}
}
private static class Rating {
private float rating = 0;
private byte winnaar = LEEG;
private int[] winKansen = null;
private Rating(byte[][] bord) {
for (int y = 0; y < bord.length; y++) {
for (int x = 0; x < bord[y].length; x++) {
boolean horizontaalKan = x + 3 < bord[y].length;
boolean verticaalKan = y + 3 < bord.length;
if (horizontaalKan) {
rate(bord, x, y, HORIZONTAAL);
}
if (verticaalKan) {
rate(bord, x, y, VERTICAAL);
if (horizontaalKan) {
rate(bord, x, y, DIAGONAAL45);
rate(bord, x, y, DIAGONAAL135);
}
}
if (winnaar != LEEG) {
rating = (winnaar == IK ? 100 : -100) * RATINGS[3];
this.winKansen = null;
return;
}
}
}
}
private void addRating(int i, boolean ik) {
if (ik) {
this.rating += i;
} else {
this.rating -= i;
}
}
private Rating(MinimaxNode[] nodes) {
// de rating is het gemiddelde van de nodes, die NIET NULL is
double ratingGem = 0;
// uit hoeveel getallen ratingGem het gemiddelde is genomen
int n = 0;
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] != null) {
ratingGem += nodes[i].rating.rating;
n++;
}
}
this.rating = (float) ratingGem / n;
this.winnaar = LEEG;
}
private void rate(byte[][] bord, int x, int y, int richting) {
int[] points = new int[8];
int aantalIK = 0, aantalHIJ = 0;
for (int i = 0; i < 4; i++) {
// x
points[i * 2] = (richting == VERTICAAL ? x : x + i);
// y
points[i * 2 + 1] = (richting == DIAGONAAL135 ? y + 3 - i
: (richting == HORIZONTAAL ? y : y + i));
if (bord[points[i * 2 + 1]][points[i * 2]] == IK) {
aantalIK++;
} else if (bord[points[i * 2 + 1]][points[i * 2]] == HIJ) {
aantalHIJ++;
}
}
if (aantalIK == 4) {
this.winnaar = IK;
} else if (aantalHIJ == 4) {
this.winnaar = HIJ;
} else if ((aantalIK == 3 && aantalHIJ == 0)
|| (aantalHIJ == 3 && aantalIK == 0)) {
for (int i = 0; i < 4; i++) {
if (bord[points[i * 2 + 1]][points[i * 2]] == LEEG) {
boolean ik = (aantalIK == 3);
int missingX = points[i * 2], missingY = points[i * 2 + 1];
if (missingY == 0
|| bord[missingY - 1][missingX] != LEEG) {
addVerplichteZet(missingX);
addRating(RATINGS[2], ik);
} else if (((isWit == ik) && (y & 1) == 0)
|| ((isWit != ik) && (y & 1) == 1)) {
addRating(10 * RATINGS[2], ik);
} else {
addRating(2 * RATINGS[2], ik);
}
break;
}
}
} else if (aantalIK != 0 && aantalHIJ == 0) {
// 'ik' heeft een rij :). De rating is positief
addRating(RATINGS[aantalIK - 1], true);
}
}
private void addVerplichteZet(int x) {
if (winKansen == null) {
winKansen = new int[] { x };
} else {
// de oude grootte van de array maar ook de index van het nieuwe
// element
final int len = winKansen.length;
for (int i = 0; i < len; i++) {
if (winKansen[i] == x) {
return;
}
}
// unieke kolom
int[] newarray = new int[len + 1];
System.arraycopy(winKansen, 0, newarray, 0, len);
newarray[len] = x;
winKansen = newarray;
}
}
@Override
public String toString() {
String str = "(r: " + rating;
if (winnaar != LEEG) {
str += ",w: " + winnaar;
}
if (winKansen != null) {
str += ",z: " + Arrays.toString(winKansen);
}
return str + ")";
}
}
/**
* doet een zet op het speelbord, en geeft dit bord terug. Het bord wordt
* niet aangepast, maar er wordt een nieuw speelbord aangemaakt
*
* @return het nieuwe bord
*/
private static byte[][] doeZet(byte[][] oudBord, byte kleur, int kolom)
throws IllegalStateException {
byte[][] bord = new byte[HOOGTE][BREEDTE];
for (int y = 0; y < HOOGTE; y++) {
System.arraycopy(oudBord[y], 0, bord[y], 0, BREEDTE);
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][kolom] == LEEG) {
bord[y][kolom] = kleur;
return bord;
}
}
// het bord is in deze kolom vol
throw new IllegalStateException("Kolom " + (kolom + 1) + " is vol\n");
}
private static int stappenVooruit() {
long tijd_bezig = getTijdBezig();
// System.err.print("tijdBezig=" + tijd_bezig + ",stappenVooruit=");
if (tijd_bezig > 3500) {
// System.err.println(4);
return 4;
}
// System.err.println(5);
return 5;
}
private static long tijdBezig = 0;
private static long beginRonde = 0;
private static long getTijdBezig() {
return tijdBezig + (System.currentTimeMillis() - beginRonde);
}
private static void updateNodes(byte[][] bord, int zet, boolean hijZette) {
if (hijZette) {
if (huidigeNode == null) {
// (waarschijnlijk) de eerste keer
huidigeNode = new MinimaxNode(bord, HIJ, stappenVooruit());
} else {
if (huidigeNode.nodes == null || huidigeNode.nodes[zet] == null
&& huidigeNode.initNode(zet) == null) {
// de zet kan nu niet op het bord worden gemaakt, dus
// passen we het bord niet aan.
huidigeNode = new MinimaxNode(bord, IK, stappenVooruit());
} else {
huidigeNode = huidigeNode.nodes[zet];
huidigeNode.denkVooruit(stappenVooruit());
}
}
huidigeNode.initNodes();
} else {
if (huidigeNode == null || huidigeNode.nodes == null) {
huidigeNode = null;
} else {
huidigeNode = huidigeNode.nodes[zet];
}
}
}
public static void main(String[] args) throws IOException {
// 435644536335625262
// luistert naar zetten van de tegenstander
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// [0][0] = links onderin, [5][6] = rechts bovenin
byte[][] bord = new byte[HOOGTE][BREEDTE];
// firsterror
// System.err.println("R Ludiquatre");
// System.err.flush();
String zet;
while ((zet = in.readLine()) != null) {
if (zet.length() == 0) {
// soms hebben we gewoon niets te zeggen
continue;
} else if (zet.equalsIgnoreCase("quit")) {
// tot ziens!
break;
} else if (zet.equalsIgnoreCase("start")) {
// Ik mag beginnen. We doen het midden, dat is het chillst
isWit = true;
int mijnZet = 3;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
} else if (zet.length() != 1 || zet.charAt(0) < '1'
|| zet.charAt(0) > '7') {
// System.err.println("Invalid input '" + zet + "'!");
// System.err.flush();
// wie de bal kaatst, kan hem terug verwachten ;)
System.out.println(zet);
System.out.flush();
} else {
// een getal tussen de 1 en de 7 die de tegenstander heeft
// gespeeld
beginRonde = System.currentTimeMillis();
// zijn zet
int zijnZet = Integer.parseInt(zet.trim()) - 1;
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][zijnZet] == LEEG) {
bord[y][zijnZet] = HIJ;
break;
}
}
// print(bord);
updateNodes(bord, zijnZet, true);
// mijn zet
int mijnZet = huidigeNode.besteZet(true);
if (mijnZet == -1) {
mijnZet = 3;
}
for (int y = 0; y < HOOGTE; y++) {
if (bord[y][mijnZet] == LEEG) {
bord[y][mijnZet] = IK;
break;
}
}
updateNodes(bord, mijnZet, false);
long tijdBeginZet = System.currentTimeMillis() - beginRonde;
tijdBezig += tijdBeginZet;
// print(huidigeNode);
// System.err.println("tijd bezig: " + tijdBeginZet);
// print(bord);
// System.err.println(mijnZet + 1);
// System.err.flush();
System.out.println(mijnZet + 1);
System.out.flush();
}
}
// System.err.println("tijd: "<SUF>
// System.err.flush();
}
/*
private static void print(byte[][] bord) {
StringBuilder sb = new StringBuilder(BREEDTE * HOOGTE);
for (int y = bord.length - 1; y >= 0; y--) {
for (int x = 0; x < bord[y].length; x++) {
if (x != 0) {
sb.append("|");
}
sb.append(bord[y][x]);
}
sb.append('\n');
}
System.err.println(sb);
}
private static void print(MinimaxNode node) {
if (node == null || node.nodes == null) {
System.err.println("null");
return;
}
for (int i = 0; i < node.nodes.length; i++) {
MinimaxNode nodeN = node.nodes[i];
System.err.println((i + 1) + ": "
+ (nodeN == null ? "null" : nodeN.rating));
}
}
*/
} |
1689_0 | package com.busenzo.domein;
import java.time.LocalDateTime;
public class Rit {
private LocalDateTime verwachteAankomstTijd;
private LocalDateTime aankomstTijd;
private Bus bus;
private Lijn lijn;
private String ID;
/**
* Maak een rit aan op een bepaalde lijn
* @param verwachtteAankomstTijd De verwachtte aankomsttijd bij de eindhalte
* @param lijn: De lijn waarbij deze rit hoort, nooit null
*/
public Rit(LocalDateTime verwachtteAankomstTijd, Lijn lijn, String ritID) {
this.lijn = lijn;
this.verwachteAankomstTijd = verwachtteAankomstTijd;
this.ID = ritID;
}
/**
* Haal de bus op die deze rit rijdt.
* @return De bus die deze rit rijdt. Kan null zijn als de rit nog niet vertrokken is
*/
public Bus getBus() {
return this.bus;
}
public String getRitID()
{
return this.ID;
}
public void setAankomstTijd(LocalDateTime aankomstTijd)
{
this.aankomstTijd = aankomstTijd;
}
/**
* Haal de lijn op waarbij deze rit hoort
* @return De lijn waarop deze rit rijdt
*/
public Lijn getLijn() {
return this.lijn;
}
/**
* Haal de verwachtte aankomsttijd bij de eindhalte op
* @return de verwachtte aankomsttijd bij de eindhalte
*/
public LocalDateTime getVerwachteAankomstTijd() {
return verwachteAankomstTijd;
}
/**
* Vraag de verwachtte aankomsttijd op bij de volgende halte
* @return De verwachtte aankomsttijd bij de volgende halte
*/
public LocalDateTime getAankomstTijd() {
return aankomstTijd;
}
/**
* Voeg een bus toe welke deze rit gaat rijden.
* @param bus : De bus die deze rit gaat rijden, mag niet null zijn
*/
public void setBus(Bus bus) {
this.bus = bus;
}
} | maartenpeels/Bus-Tracker | src/com/busenzo/domein/Rit.java | 548 | /**
* Maak een rit aan op een bepaalde lijn
* @param verwachtteAankomstTijd De verwachtte aankomsttijd bij de eindhalte
* @param lijn: De lijn waarbij deze rit hoort, nooit null
*/ | block_comment | nl | package com.busenzo.domein;
import java.time.LocalDateTime;
public class Rit {
private LocalDateTime verwachteAankomstTijd;
private LocalDateTime aankomstTijd;
private Bus bus;
private Lijn lijn;
private String ID;
/**
* Maak een rit<SUF>*/
public Rit(LocalDateTime verwachtteAankomstTijd, Lijn lijn, String ritID) {
this.lijn = lijn;
this.verwachteAankomstTijd = verwachtteAankomstTijd;
this.ID = ritID;
}
/**
* Haal de bus op die deze rit rijdt.
* @return De bus die deze rit rijdt. Kan null zijn als de rit nog niet vertrokken is
*/
public Bus getBus() {
return this.bus;
}
public String getRitID()
{
return this.ID;
}
public void setAankomstTijd(LocalDateTime aankomstTijd)
{
this.aankomstTijd = aankomstTijd;
}
/**
* Haal de lijn op waarbij deze rit hoort
* @return De lijn waarop deze rit rijdt
*/
public Lijn getLijn() {
return this.lijn;
}
/**
* Haal de verwachtte aankomsttijd bij de eindhalte op
* @return de verwachtte aankomsttijd bij de eindhalte
*/
public LocalDateTime getVerwachteAankomstTijd() {
return verwachteAankomstTijd;
}
/**
* Vraag de verwachtte aankomsttijd op bij de volgende halte
* @return De verwachtte aankomsttijd bij de volgende halte
*/
public LocalDateTime getAankomstTijd() {
return aankomstTijd;
}
/**
* Voeg een bus toe welke deze rit gaat rijden.
* @param bus : De bus die deze rit gaat rijden, mag niet null zijn
*/
public void setBus(Bus bus) {
this.bus = bus;
}
} |
1689_1 | package com.busenzo.domein;
import java.time.LocalDateTime;
public class Rit {
private LocalDateTime verwachteAankomstTijd;
private LocalDateTime aankomstTijd;
private Bus bus;
private Lijn lijn;
private String ID;
/**
* Maak een rit aan op een bepaalde lijn
* @param verwachtteAankomstTijd De verwachtte aankomsttijd bij de eindhalte
* @param lijn: De lijn waarbij deze rit hoort, nooit null
*/
public Rit(LocalDateTime verwachtteAankomstTijd, Lijn lijn, String ritID) {
this.lijn = lijn;
this.verwachteAankomstTijd = verwachtteAankomstTijd;
this.ID = ritID;
}
/**
* Haal de bus op die deze rit rijdt.
* @return De bus die deze rit rijdt. Kan null zijn als de rit nog niet vertrokken is
*/
public Bus getBus() {
return this.bus;
}
public String getRitID()
{
return this.ID;
}
public void setAankomstTijd(LocalDateTime aankomstTijd)
{
this.aankomstTijd = aankomstTijd;
}
/**
* Haal de lijn op waarbij deze rit hoort
* @return De lijn waarop deze rit rijdt
*/
public Lijn getLijn() {
return this.lijn;
}
/**
* Haal de verwachtte aankomsttijd bij de eindhalte op
* @return de verwachtte aankomsttijd bij de eindhalte
*/
public LocalDateTime getVerwachteAankomstTijd() {
return verwachteAankomstTijd;
}
/**
* Vraag de verwachtte aankomsttijd op bij de volgende halte
* @return De verwachtte aankomsttijd bij de volgende halte
*/
public LocalDateTime getAankomstTijd() {
return aankomstTijd;
}
/**
* Voeg een bus toe welke deze rit gaat rijden.
* @param bus : De bus die deze rit gaat rijden, mag niet null zijn
*/
public void setBus(Bus bus) {
this.bus = bus;
}
} | maartenpeels/Bus-Tracker | src/com/busenzo/domein/Rit.java | 548 | /**
* Haal de bus op die deze rit rijdt.
* @return De bus die deze rit rijdt. Kan null zijn als de rit nog niet vertrokken is
*/ | block_comment | nl | package com.busenzo.domein;
import java.time.LocalDateTime;
public class Rit {
private LocalDateTime verwachteAankomstTijd;
private LocalDateTime aankomstTijd;
private Bus bus;
private Lijn lijn;
private String ID;
/**
* Maak een rit aan op een bepaalde lijn
* @param verwachtteAankomstTijd De verwachtte aankomsttijd bij de eindhalte
* @param lijn: De lijn waarbij deze rit hoort, nooit null
*/
public Rit(LocalDateTime verwachtteAankomstTijd, Lijn lijn, String ritID) {
this.lijn = lijn;
this.verwachteAankomstTijd = verwachtteAankomstTijd;
this.ID = ritID;
}
/**
* Haal de bus<SUF>*/
public Bus getBus() {
return this.bus;
}
public String getRitID()
{
return this.ID;
}
public void setAankomstTijd(LocalDateTime aankomstTijd)
{
this.aankomstTijd = aankomstTijd;
}
/**
* Haal de lijn op waarbij deze rit hoort
* @return De lijn waarop deze rit rijdt
*/
public Lijn getLijn() {
return this.lijn;
}
/**
* Haal de verwachtte aankomsttijd bij de eindhalte op
* @return de verwachtte aankomsttijd bij de eindhalte
*/
public LocalDateTime getVerwachteAankomstTijd() {
return verwachteAankomstTijd;
}
/**
* Vraag de verwachtte aankomsttijd op bij de volgende halte
* @return De verwachtte aankomsttijd bij de volgende halte
*/
public LocalDateTime getAankomstTijd() {
return aankomstTijd;
}
/**
* Voeg een bus toe welke deze rit gaat rijden.
* @param bus : De bus die deze rit gaat rijden, mag niet null zijn
*/
public void setBus(Bus bus) {
this.bus = bus;
}
} |
1689_2 | package com.busenzo.domein;
import java.time.LocalDateTime;
public class Rit {
private LocalDateTime verwachteAankomstTijd;
private LocalDateTime aankomstTijd;
private Bus bus;
private Lijn lijn;
private String ID;
/**
* Maak een rit aan op een bepaalde lijn
* @param verwachtteAankomstTijd De verwachtte aankomsttijd bij de eindhalte
* @param lijn: De lijn waarbij deze rit hoort, nooit null
*/
public Rit(LocalDateTime verwachtteAankomstTijd, Lijn lijn, String ritID) {
this.lijn = lijn;
this.verwachteAankomstTijd = verwachtteAankomstTijd;
this.ID = ritID;
}
/**
* Haal de bus op die deze rit rijdt.
* @return De bus die deze rit rijdt. Kan null zijn als de rit nog niet vertrokken is
*/
public Bus getBus() {
return this.bus;
}
public String getRitID()
{
return this.ID;
}
public void setAankomstTijd(LocalDateTime aankomstTijd)
{
this.aankomstTijd = aankomstTijd;
}
/**
* Haal de lijn op waarbij deze rit hoort
* @return De lijn waarop deze rit rijdt
*/
public Lijn getLijn() {
return this.lijn;
}
/**
* Haal de verwachtte aankomsttijd bij de eindhalte op
* @return de verwachtte aankomsttijd bij de eindhalte
*/
public LocalDateTime getVerwachteAankomstTijd() {
return verwachteAankomstTijd;
}
/**
* Vraag de verwachtte aankomsttijd op bij de volgende halte
* @return De verwachtte aankomsttijd bij de volgende halte
*/
public LocalDateTime getAankomstTijd() {
return aankomstTijd;
}
/**
* Voeg een bus toe welke deze rit gaat rijden.
* @param bus : De bus die deze rit gaat rijden, mag niet null zijn
*/
public void setBus(Bus bus) {
this.bus = bus;
}
} | maartenpeels/Bus-Tracker | src/com/busenzo/domein/Rit.java | 548 | /**
* Haal de lijn op waarbij deze rit hoort
* @return De lijn waarop deze rit rijdt
*/ | block_comment | nl | package com.busenzo.domein;
import java.time.LocalDateTime;
public class Rit {
private LocalDateTime verwachteAankomstTijd;
private LocalDateTime aankomstTijd;
private Bus bus;
private Lijn lijn;
private String ID;
/**
* Maak een rit aan op een bepaalde lijn
* @param verwachtteAankomstTijd De verwachtte aankomsttijd bij de eindhalte
* @param lijn: De lijn waarbij deze rit hoort, nooit null
*/
public Rit(LocalDateTime verwachtteAankomstTijd, Lijn lijn, String ritID) {
this.lijn = lijn;
this.verwachteAankomstTijd = verwachtteAankomstTijd;
this.ID = ritID;
}
/**
* Haal de bus op die deze rit rijdt.
* @return De bus die deze rit rijdt. Kan null zijn als de rit nog niet vertrokken is
*/
public Bus getBus() {
return this.bus;
}
public String getRitID()
{
return this.ID;
}
public void setAankomstTijd(LocalDateTime aankomstTijd)
{
this.aankomstTijd = aankomstTijd;
}
/**
* Haal de lijn<SUF>*/
public Lijn getLijn() {
return this.lijn;
}
/**
* Haal de verwachtte aankomsttijd bij de eindhalte op
* @return de verwachtte aankomsttijd bij de eindhalte
*/
public LocalDateTime getVerwachteAankomstTijd() {
return verwachteAankomstTijd;
}
/**
* Vraag de verwachtte aankomsttijd op bij de volgende halte
* @return De verwachtte aankomsttijd bij de volgende halte
*/
public LocalDateTime getAankomstTijd() {
return aankomstTijd;
}
/**
* Voeg een bus toe welke deze rit gaat rijden.
* @param bus : De bus die deze rit gaat rijden, mag niet null zijn
*/
public void setBus(Bus bus) {
this.bus = bus;
}
} |
1689_3 | package com.busenzo.domein;
import java.time.LocalDateTime;
public class Rit {
private LocalDateTime verwachteAankomstTijd;
private LocalDateTime aankomstTijd;
private Bus bus;
private Lijn lijn;
private String ID;
/**
* Maak een rit aan op een bepaalde lijn
* @param verwachtteAankomstTijd De verwachtte aankomsttijd bij de eindhalte
* @param lijn: De lijn waarbij deze rit hoort, nooit null
*/
public Rit(LocalDateTime verwachtteAankomstTijd, Lijn lijn, String ritID) {
this.lijn = lijn;
this.verwachteAankomstTijd = verwachtteAankomstTijd;
this.ID = ritID;
}
/**
* Haal de bus op die deze rit rijdt.
* @return De bus die deze rit rijdt. Kan null zijn als de rit nog niet vertrokken is
*/
public Bus getBus() {
return this.bus;
}
public String getRitID()
{
return this.ID;
}
public void setAankomstTijd(LocalDateTime aankomstTijd)
{
this.aankomstTijd = aankomstTijd;
}
/**
* Haal de lijn op waarbij deze rit hoort
* @return De lijn waarop deze rit rijdt
*/
public Lijn getLijn() {
return this.lijn;
}
/**
* Haal de verwachtte aankomsttijd bij de eindhalte op
* @return de verwachtte aankomsttijd bij de eindhalte
*/
public LocalDateTime getVerwachteAankomstTijd() {
return verwachteAankomstTijd;
}
/**
* Vraag de verwachtte aankomsttijd op bij de volgende halte
* @return De verwachtte aankomsttijd bij de volgende halte
*/
public LocalDateTime getAankomstTijd() {
return aankomstTijd;
}
/**
* Voeg een bus toe welke deze rit gaat rijden.
* @param bus : De bus die deze rit gaat rijden, mag niet null zijn
*/
public void setBus(Bus bus) {
this.bus = bus;
}
} | maartenpeels/Bus-Tracker | src/com/busenzo/domein/Rit.java | 548 | /**
* Haal de verwachtte aankomsttijd bij de eindhalte op
* @return de verwachtte aankomsttijd bij de eindhalte
*/ | block_comment | nl | package com.busenzo.domein;
import java.time.LocalDateTime;
public class Rit {
private LocalDateTime verwachteAankomstTijd;
private LocalDateTime aankomstTijd;
private Bus bus;
private Lijn lijn;
private String ID;
/**
* Maak een rit aan op een bepaalde lijn
* @param verwachtteAankomstTijd De verwachtte aankomsttijd bij de eindhalte
* @param lijn: De lijn waarbij deze rit hoort, nooit null
*/
public Rit(LocalDateTime verwachtteAankomstTijd, Lijn lijn, String ritID) {
this.lijn = lijn;
this.verwachteAankomstTijd = verwachtteAankomstTijd;
this.ID = ritID;
}
/**
* Haal de bus op die deze rit rijdt.
* @return De bus die deze rit rijdt. Kan null zijn als de rit nog niet vertrokken is
*/
public Bus getBus() {
return this.bus;
}
public String getRitID()
{
return this.ID;
}
public void setAankomstTijd(LocalDateTime aankomstTijd)
{
this.aankomstTijd = aankomstTijd;
}
/**
* Haal de lijn op waarbij deze rit hoort
* @return De lijn waarop deze rit rijdt
*/
public Lijn getLijn() {
return this.lijn;
}
/**
* Haal de verwachtte<SUF>*/
public LocalDateTime getVerwachteAankomstTijd() {
return verwachteAankomstTijd;
}
/**
* Vraag de verwachtte aankomsttijd op bij de volgende halte
* @return De verwachtte aankomsttijd bij de volgende halte
*/
public LocalDateTime getAankomstTijd() {
return aankomstTijd;
}
/**
* Voeg een bus toe welke deze rit gaat rijden.
* @param bus : De bus die deze rit gaat rijden, mag niet null zijn
*/
public void setBus(Bus bus) {
this.bus = bus;
}
} |
1689_4 | package com.busenzo.domein;
import java.time.LocalDateTime;
public class Rit {
private LocalDateTime verwachteAankomstTijd;
private LocalDateTime aankomstTijd;
private Bus bus;
private Lijn lijn;
private String ID;
/**
* Maak een rit aan op een bepaalde lijn
* @param verwachtteAankomstTijd De verwachtte aankomsttijd bij de eindhalte
* @param lijn: De lijn waarbij deze rit hoort, nooit null
*/
public Rit(LocalDateTime verwachtteAankomstTijd, Lijn lijn, String ritID) {
this.lijn = lijn;
this.verwachteAankomstTijd = verwachtteAankomstTijd;
this.ID = ritID;
}
/**
* Haal de bus op die deze rit rijdt.
* @return De bus die deze rit rijdt. Kan null zijn als de rit nog niet vertrokken is
*/
public Bus getBus() {
return this.bus;
}
public String getRitID()
{
return this.ID;
}
public void setAankomstTijd(LocalDateTime aankomstTijd)
{
this.aankomstTijd = aankomstTijd;
}
/**
* Haal de lijn op waarbij deze rit hoort
* @return De lijn waarop deze rit rijdt
*/
public Lijn getLijn() {
return this.lijn;
}
/**
* Haal de verwachtte aankomsttijd bij de eindhalte op
* @return de verwachtte aankomsttijd bij de eindhalte
*/
public LocalDateTime getVerwachteAankomstTijd() {
return verwachteAankomstTijd;
}
/**
* Vraag de verwachtte aankomsttijd op bij de volgende halte
* @return De verwachtte aankomsttijd bij de volgende halte
*/
public LocalDateTime getAankomstTijd() {
return aankomstTijd;
}
/**
* Voeg een bus toe welke deze rit gaat rijden.
* @param bus : De bus die deze rit gaat rijden, mag niet null zijn
*/
public void setBus(Bus bus) {
this.bus = bus;
}
} | maartenpeels/Bus-Tracker | src/com/busenzo/domein/Rit.java | 548 | /**
* Vraag de verwachtte aankomsttijd op bij de volgende halte
* @return De verwachtte aankomsttijd bij de volgende halte
*/ | block_comment | nl | package com.busenzo.domein;
import java.time.LocalDateTime;
public class Rit {
private LocalDateTime verwachteAankomstTijd;
private LocalDateTime aankomstTijd;
private Bus bus;
private Lijn lijn;
private String ID;
/**
* Maak een rit aan op een bepaalde lijn
* @param verwachtteAankomstTijd De verwachtte aankomsttijd bij de eindhalte
* @param lijn: De lijn waarbij deze rit hoort, nooit null
*/
public Rit(LocalDateTime verwachtteAankomstTijd, Lijn lijn, String ritID) {
this.lijn = lijn;
this.verwachteAankomstTijd = verwachtteAankomstTijd;
this.ID = ritID;
}
/**
* Haal de bus op die deze rit rijdt.
* @return De bus die deze rit rijdt. Kan null zijn als de rit nog niet vertrokken is
*/
public Bus getBus() {
return this.bus;
}
public String getRitID()
{
return this.ID;
}
public void setAankomstTijd(LocalDateTime aankomstTijd)
{
this.aankomstTijd = aankomstTijd;
}
/**
* Haal de lijn op waarbij deze rit hoort
* @return De lijn waarop deze rit rijdt
*/
public Lijn getLijn() {
return this.lijn;
}
/**
* Haal de verwachtte aankomsttijd bij de eindhalte op
* @return de verwachtte aankomsttijd bij de eindhalte
*/
public LocalDateTime getVerwachteAankomstTijd() {
return verwachteAankomstTijd;
}
/**
* Vraag de verwachtte<SUF>*/
public LocalDateTime getAankomstTijd() {
return aankomstTijd;
}
/**
* Voeg een bus toe welke deze rit gaat rijden.
* @param bus : De bus die deze rit gaat rijden, mag niet null zijn
*/
public void setBus(Bus bus) {
this.bus = bus;
}
} |
1689_5 | package com.busenzo.domein;
import java.time.LocalDateTime;
public class Rit {
private LocalDateTime verwachteAankomstTijd;
private LocalDateTime aankomstTijd;
private Bus bus;
private Lijn lijn;
private String ID;
/**
* Maak een rit aan op een bepaalde lijn
* @param verwachtteAankomstTijd De verwachtte aankomsttijd bij de eindhalte
* @param lijn: De lijn waarbij deze rit hoort, nooit null
*/
public Rit(LocalDateTime verwachtteAankomstTijd, Lijn lijn, String ritID) {
this.lijn = lijn;
this.verwachteAankomstTijd = verwachtteAankomstTijd;
this.ID = ritID;
}
/**
* Haal de bus op die deze rit rijdt.
* @return De bus die deze rit rijdt. Kan null zijn als de rit nog niet vertrokken is
*/
public Bus getBus() {
return this.bus;
}
public String getRitID()
{
return this.ID;
}
public void setAankomstTijd(LocalDateTime aankomstTijd)
{
this.aankomstTijd = aankomstTijd;
}
/**
* Haal de lijn op waarbij deze rit hoort
* @return De lijn waarop deze rit rijdt
*/
public Lijn getLijn() {
return this.lijn;
}
/**
* Haal de verwachtte aankomsttijd bij de eindhalte op
* @return de verwachtte aankomsttijd bij de eindhalte
*/
public LocalDateTime getVerwachteAankomstTijd() {
return verwachteAankomstTijd;
}
/**
* Vraag de verwachtte aankomsttijd op bij de volgende halte
* @return De verwachtte aankomsttijd bij de volgende halte
*/
public LocalDateTime getAankomstTijd() {
return aankomstTijd;
}
/**
* Voeg een bus toe welke deze rit gaat rijden.
* @param bus : De bus die deze rit gaat rijden, mag niet null zijn
*/
public void setBus(Bus bus) {
this.bus = bus;
}
} | maartenpeels/Bus-Tracker | src/com/busenzo/domein/Rit.java | 548 | /**
* Voeg een bus toe welke deze rit gaat rijden.
* @param bus : De bus die deze rit gaat rijden, mag niet null zijn
*/ | block_comment | nl | package com.busenzo.domein;
import java.time.LocalDateTime;
public class Rit {
private LocalDateTime verwachteAankomstTijd;
private LocalDateTime aankomstTijd;
private Bus bus;
private Lijn lijn;
private String ID;
/**
* Maak een rit aan op een bepaalde lijn
* @param verwachtteAankomstTijd De verwachtte aankomsttijd bij de eindhalte
* @param lijn: De lijn waarbij deze rit hoort, nooit null
*/
public Rit(LocalDateTime verwachtteAankomstTijd, Lijn lijn, String ritID) {
this.lijn = lijn;
this.verwachteAankomstTijd = verwachtteAankomstTijd;
this.ID = ritID;
}
/**
* Haal de bus op die deze rit rijdt.
* @return De bus die deze rit rijdt. Kan null zijn als de rit nog niet vertrokken is
*/
public Bus getBus() {
return this.bus;
}
public String getRitID()
{
return this.ID;
}
public void setAankomstTijd(LocalDateTime aankomstTijd)
{
this.aankomstTijd = aankomstTijd;
}
/**
* Haal de lijn op waarbij deze rit hoort
* @return De lijn waarop deze rit rijdt
*/
public Lijn getLijn() {
return this.lijn;
}
/**
* Haal de verwachtte aankomsttijd bij de eindhalte op
* @return de verwachtte aankomsttijd bij de eindhalte
*/
public LocalDateTime getVerwachteAankomstTijd() {
return verwachteAankomstTijd;
}
/**
* Vraag de verwachtte aankomsttijd op bij de volgende halte
* @return De verwachtte aankomsttijd bij de volgende halte
*/
public LocalDateTime getAankomstTijd() {
return aankomstTijd;
}
/**
* Voeg een bus<SUF>*/
public void setBus(Bus bus) {
this.bus = bus;
}
} |
1690_0 | package com.busenzo.domein;
public class Bus {
private int nummer;
private double lon;
private double lat;
private Rit huidigeRit;
/**
* Maak een nieuwe bus aan met een specifiek chassisnummer. Er mag nog geen bus bestaan met het gegeven nummer
* @param nummer Het chassisnummer dat deze bus moet krijgen. Altijd groter als 0.
*/
public Bus(int nummer) {
if(nummer < 0){
throw new IllegalArgumentException();
}
this.nummer = nummer;
}
/**
* Update de locatie van deze bus
* @param lon: De nieuwe longditude van deze bus
* @param lat: De nieuwe ladditude van deze bus
*/
public void updateLocatie(double lat, double lon) {
this.lat = lat;
this.lon = lon;
}
/**
* Haal het chassisnummer van de bus op
* @return Het nummer van deze bus
*/
public int getNummer(){
return this.nummer;
}
/**
* Vraag de huidige rit van deze bus op
* @return De huidige rit of null als deze bus niet aan een rit bezig is.
*/
public Rit getHuidigeRit(){
return this.huidigeRit;
}
/**
* Zet de huidige rit van deze bus
* @param rit De rit die deze bus gaat maken. Nooit null
*/
public void setHuidigeRit(Rit rit){
this.huidigeRit = rit;
}
/**
* Vraag de coordinaten op van de plek waar deze bus zich momenteel bevind
* @return Een array met hierin de lon en lat. Kan leeg zijn als de coordinaten van deze bus niet gezet zijn
*/
public double[] getCoordinaten(){
double[] cords = {this.lat, this.lon};
return cords;
}
} | maartenpeels/Bus-Tracker | src/com/busenzo/domein/Bus.java | 496 | /**
* Maak een nieuwe bus aan met een specifiek chassisnummer. Er mag nog geen bus bestaan met het gegeven nummer
* @param nummer Het chassisnummer dat deze bus moet krijgen. Altijd groter als 0.
*/ | block_comment | nl | package com.busenzo.domein;
public class Bus {
private int nummer;
private double lon;
private double lat;
private Rit huidigeRit;
/**
* Maak een nieuwe<SUF>*/
public Bus(int nummer) {
if(nummer < 0){
throw new IllegalArgumentException();
}
this.nummer = nummer;
}
/**
* Update de locatie van deze bus
* @param lon: De nieuwe longditude van deze bus
* @param lat: De nieuwe ladditude van deze bus
*/
public void updateLocatie(double lat, double lon) {
this.lat = lat;
this.lon = lon;
}
/**
* Haal het chassisnummer van de bus op
* @return Het nummer van deze bus
*/
public int getNummer(){
return this.nummer;
}
/**
* Vraag de huidige rit van deze bus op
* @return De huidige rit of null als deze bus niet aan een rit bezig is.
*/
public Rit getHuidigeRit(){
return this.huidigeRit;
}
/**
* Zet de huidige rit van deze bus
* @param rit De rit die deze bus gaat maken. Nooit null
*/
public void setHuidigeRit(Rit rit){
this.huidigeRit = rit;
}
/**
* Vraag de coordinaten op van de plek waar deze bus zich momenteel bevind
* @return Een array met hierin de lon en lat. Kan leeg zijn als de coordinaten van deze bus niet gezet zijn
*/
public double[] getCoordinaten(){
double[] cords = {this.lat, this.lon};
return cords;
}
} |
1690_1 | package com.busenzo.domein;
public class Bus {
private int nummer;
private double lon;
private double lat;
private Rit huidigeRit;
/**
* Maak een nieuwe bus aan met een specifiek chassisnummer. Er mag nog geen bus bestaan met het gegeven nummer
* @param nummer Het chassisnummer dat deze bus moet krijgen. Altijd groter als 0.
*/
public Bus(int nummer) {
if(nummer < 0){
throw new IllegalArgumentException();
}
this.nummer = nummer;
}
/**
* Update de locatie van deze bus
* @param lon: De nieuwe longditude van deze bus
* @param lat: De nieuwe ladditude van deze bus
*/
public void updateLocatie(double lat, double lon) {
this.lat = lat;
this.lon = lon;
}
/**
* Haal het chassisnummer van de bus op
* @return Het nummer van deze bus
*/
public int getNummer(){
return this.nummer;
}
/**
* Vraag de huidige rit van deze bus op
* @return De huidige rit of null als deze bus niet aan een rit bezig is.
*/
public Rit getHuidigeRit(){
return this.huidigeRit;
}
/**
* Zet de huidige rit van deze bus
* @param rit De rit die deze bus gaat maken. Nooit null
*/
public void setHuidigeRit(Rit rit){
this.huidigeRit = rit;
}
/**
* Vraag de coordinaten op van de plek waar deze bus zich momenteel bevind
* @return Een array met hierin de lon en lat. Kan leeg zijn als de coordinaten van deze bus niet gezet zijn
*/
public double[] getCoordinaten(){
double[] cords = {this.lat, this.lon};
return cords;
}
} | maartenpeels/Bus-Tracker | src/com/busenzo/domein/Bus.java | 496 | /**
* Update de locatie van deze bus
* @param lon: De nieuwe longditude van deze bus
* @param lat: De nieuwe ladditude van deze bus
*/ | block_comment | nl | package com.busenzo.domein;
public class Bus {
private int nummer;
private double lon;
private double lat;
private Rit huidigeRit;
/**
* Maak een nieuwe bus aan met een specifiek chassisnummer. Er mag nog geen bus bestaan met het gegeven nummer
* @param nummer Het chassisnummer dat deze bus moet krijgen. Altijd groter als 0.
*/
public Bus(int nummer) {
if(nummer < 0){
throw new IllegalArgumentException();
}
this.nummer = nummer;
}
/**
* Update de locatie<SUF>*/
public void updateLocatie(double lat, double lon) {
this.lat = lat;
this.lon = lon;
}
/**
* Haal het chassisnummer van de bus op
* @return Het nummer van deze bus
*/
public int getNummer(){
return this.nummer;
}
/**
* Vraag de huidige rit van deze bus op
* @return De huidige rit of null als deze bus niet aan een rit bezig is.
*/
public Rit getHuidigeRit(){
return this.huidigeRit;
}
/**
* Zet de huidige rit van deze bus
* @param rit De rit die deze bus gaat maken. Nooit null
*/
public void setHuidigeRit(Rit rit){
this.huidigeRit = rit;
}
/**
* Vraag de coordinaten op van de plek waar deze bus zich momenteel bevind
* @return Een array met hierin de lon en lat. Kan leeg zijn als de coordinaten van deze bus niet gezet zijn
*/
public double[] getCoordinaten(){
double[] cords = {this.lat, this.lon};
return cords;
}
} |
1690_2 | package com.busenzo.domein;
public class Bus {
private int nummer;
private double lon;
private double lat;
private Rit huidigeRit;
/**
* Maak een nieuwe bus aan met een specifiek chassisnummer. Er mag nog geen bus bestaan met het gegeven nummer
* @param nummer Het chassisnummer dat deze bus moet krijgen. Altijd groter als 0.
*/
public Bus(int nummer) {
if(nummer < 0){
throw new IllegalArgumentException();
}
this.nummer = nummer;
}
/**
* Update de locatie van deze bus
* @param lon: De nieuwe longditude van deze bus
* @param lat: De nieuwe ladditude van deze bus
*/
public void updateLocatie(double lat, double lon) {
this.lat = lat;
this.lon = lon;
}
/**
* Haal het chassisnummer van de bus op
* @return Het nummer van deze bus
*/
public int getNummer(){
return this.nummer;
}
/**
* Vraag de huidige rit van deze bus op
* @return De huidige rit of null als deze bus niet aan een rit bezig is.
*/
public Rit getHuidigeRit(){
return this.huidigeRit;
}
/**
* Zet de huidige rit van deze bus
* @param rit De rit die deze bus gaat maken. Nooit null
*/
public void setHuidigeRit(Rit rit){
this.huidigeRit = rit;
}
/**
* Vraag de coordinaten op van de plek waar deze bus zich momenteel bevind
* @return Een array met hierin de lon en lat. Kan leeg zijn als de coordinaten van deze bus niet gezet zijn
*/
public double[] getCoordinaten(){
double[] cords = {this.lat, this.lon};
return cords;
}
} | maartenpeels/Bus-Tracker | src/com/busenzo/domein/Bus.java | 496 | /**
* Haal het chassisnummer van de bus op
* @return Het nummer van deze bus
*/ | block_comment | nl | package com.busenzo.domein;
public class Bus {
private int nummer;
private double lon;
private double lat;
private Rit huidigeRit;
/**
* Maak een nieuwe bus aan met een specifiek chassisnummer. Er mag nog geen bus bestaan met het gegeven nummer
* @param nummer Het chassisnummer dat deze bus moet krijgen. Altijd groter als 0.
*/
public Bus(int nummer) {
if(nummer < 0){
throw new IllegalArgumentException();
}
this.nummer = nummer;
}
/**
* Update de locatie van deze bus
* @param lon: De nieuwe longditude van deze bus
* @param lat: De nieuwe ladditude van deze bus
*/
public void updateLocatie(double lat, double lon) {
this.lat = lat;
this.lon = lon;
}
/**
* Haal het chassisnummer<SUF>*/
public int getNummer(){
return this.nummer;
}
/**
* Vraag de huidige rit van deze bus op
* @return De huidige rit of null als deze bus niet aan een rit bezig is.
*/
public Rit getHuidigeRit(){
return this.huidigeRit;
}
/**
* Zet de huidige rit van deze bus
* @param rit De rit die deze bus gaat maken. Nooit null
*/
public void setHuidigeRit(Rit rit){
this.huidigeRit = rit;
}
/**
* Vraag de coordinaten op van de plek waar deze bus zich momenteel bevind
* @return Een array met hierin de lon en lat. Kan leeg zijn als de coordinaten van deze bus niet gezet zijn
*/
public double[] getCoordinaten(){
double[] cords = {this.lat, this.lon};
return cords;
}
} |
1690_3 | package com.busenzo.domein;
public class Bus {
private int nummer;
private double lon;
private double lat;
private Rit huidigeRit;
/**
* Maak een nieuwe bus aan met een specifiek chassisnummer. Er mag nog geen bus bestaan met het gegeven nummer
* @param nummer Het chassisnummer dat deze bus moet krijgen. Altijd groter als 0.
*/
public Bus(int nummer) {
if(nummer < 0){
throw new IllegalArgumentException();
}
this.nummer = nummer;
}
/**
* Update de locatie van deze bus
* @param lon: De nieuwe longditude van deze bus
* @param lat: De nieuwe ladditude van deze bus
*/
public void updateLocatie(double lat, double lon) {
this.lat = lat;
this.lon = lon;
}
/**
* Haal het chassisnummer van de bus op
* @return Het nummer van deze bus
*/
public int getNummer(){
return this.nummer;
}
/**
* Vraag de huidige rit van deze bus op
* @return De huidige rit of null als deze bus niet aan een rit bezig is.
*/
public Rit getHuidigeRit(){
return this.huidigeRit;
}
/**
* Zet de huidige rit van deze bus
* @param rit De rit die deze bus gaat maken. Nooit null
*/
public void setHuidigeRit(Rit rit){
this.huidigeRit = rit;
}
/**
* Vraag de coordinaten op van de plek waar deze bus zich momenteel bevind
* @return Een array met hierin de lon en lat. Kan leeg zijn als de coordinaten van deze bus niet gezet zijn
*/
public double[] getCoordinaten(){
double[] cords = {this.lat, this.lon};
return cords;
}
} | maartenpeels/Bus-Tracker | src/com/busenzo/domein/Bus.java | 496 | /**
* Vraag de huidige rit van deze bus op
* @return De huidige rit of null als deze bus niet aan een rit bezig is.
*/ | block_comment | nl | package com.busenzo.domein;
public class Bus {
private int nummer;
private double lon;
private double lat;
private Rit huidigeRit;
/**
* Maak een nieuwe bus aan met een specifiek chassisnummer. Er mag nog geen bus bestaan met het gegeven nummer
* @param nummer Het chassisnummer dat deze bus moet krijgen. Altijd groter als 0.
*/
public Bus(int nummer) {
if(nummer < 0){
throw new IllegalArgumentException();
}
this.nummer = nummer;
}
/**
* Update de locatie van deze bus
* @param lon: De nieuwe longditude van deze bus
* @param lat: De nieuwe ladditude van deze bus
*/
public void updateLocatie(double lat, double lon) {
this.lat = lat;
this.lon = lon;
}
/**
* Haal het chassisnummer van de bus op
* @return Het nummer van deze bus
*/
public int getNummer(){
return this.nummer;
}
/**
* Vraag de huidige<SUF>*/
public Rit getHuidigeRit(){
return this.huidigeRit;
}
/**
* Zet de huidige rit van deze bus
* @param rit De rit die deze bus gaat maken. Nooit null
*/
public void setHuidigeRit(Rit rit){
this.huidigeRit = rit;
}
/**
* Vraag de coordinaten op van de plek waar deze bus zich momenteel bevind
* @return Een array met hierin de lon en lat. Kan leeg zijn als de coordinaten van deze bus niet gezet zijn
*/
public double[] getCoordinaten(){
double[] cords = {this.lat, this.lon};
return cords;
}
} |
1690_4 | package com.busenzo.domein;
public class Bus {
private int nummer;
private double lon;
private double lat;
private Rit huidigeRit;
/**
* Maak een nieuwe bus aan met een specifiek chassisnummer. Er mag nog geen bus bestaan met het gegeven nummer
* @param nummer Het chassisnummer dat deze bus moet krijgen. Altijd groter als 0.
*/
public Bus(int nummer) {
if(nummer < 0){
throw new IllegalArgumentException();
}
this.nummer = nummer;
}
/**
* Update de locatie van deze bus
* @param lon: De nieuwe longditude van deze bus
* @param lat: De nieuwe ladditude van deze bus
*/
public void updateLocatie(double lat, double lon) {
this.lat = lat;
this.lon = lon;
}
/**
* Haal het chassisnummer van de bus op
* @return Het nummer van deze bus
*/
public int getNummer(){
return this.nummer;
}
/**
* Vraag de huidige rit van deze bus op
* @return De huidige rit of null als deze bus niet aan een rit bezig is.
*/
public Rit getHuidigeRit(){
return this.huidigeRit;
}
/**
* Zet de huidige rit van deze bus
* @param rit De rit die deze bus gaat maken. Nooit null
*/
public void setHuidigeRit(Rit rit){
this.huidigeRit = rit;
}
/**
* Vraag de coordinaten op van de plek waar deze bus zich momenteel bevind
* @return Een array met hierin de lon en lat. Kan leeg zijn als de coordinaten van deze bus niet gezet zijn
*/
public double[] getCoordinaten(){
double[] cords = {this.lat, this.lon};
return cords;
}
} | maartenpeels/Bus-Tracker | src/com/busenzo/domein/Bus.java | 496 | /**
* Zet de huidige rit van deze bus
* @param rit De rit die deze bus gaat maken. Nooit null
*/ | block_comment | nl | package com.busenzo.domein;
public class Bus {
private int nummer;
private double lon;
private double lat;
private Rit huidigeRit;
/**
* Maak een nieuwe bus aan met een specifiek chassisnummer. Er mag nog geen bus bestaan met het gegeven nummer
* @param nummer Het chassisnummer dat deze bus moet krijgen. Altijd groter als 0.
*/
public Bus(int nummer) {
if(nummer < 0){
throw new IllegalArgumentException();
}
this.nummer = nummer;
}
/**
* Update de locatie van deze bus
* @param lon: De nieuwe longditude van deze bus
* @param lat: De nieuwe ladditude van deze bus
*/
public void updateLocatie(double lat, double lon) {
this.lat = lat;
this.lon = lon;
}
/**
* Haal het chassisnummer van de bus op
* @return Het nummer van deze bus
*/
public int getNummer(){
return this.nummer;
}
/**
* Vraag de huidige rit van deze bus op
* @return De huidige rit of null als deze bus niet aan een rit bezig is.
*/
public Rit getHuidigeRit(){
return this.huidigeRit;
}
/**
* Zet de huidige<SUF>*/
public void setHuidigeRit(Rit rit){
this.huidigeRit = rit;
}
/**
* Vraag de coordinaten op van de plek waar deze bus zich momenteel bevind
* @return Een array met hierin de lon en lat. Kan leeg zijn als de coordinaten van deze bus niet gezet zijn
*/
public double[] getCoordinaten(){
double[] cords = {this.lat, this.lon};
return cords;
}
} |
1690_5 | package com.busenzo.domein;
public class Bus {
private int nummer;
private double lon;
private double lat;
private Rit huidigeRit;
/**
* Maak een nieuwe bus aan met een specifiek chassisnummer. Er mag nog geen bus bestaan met het gegeven nummer
* @param nummer Het chassisnummer dat deze bus moet krijgen. Altijd groter als 0.
*/
public Bus(int nummer) {
if(nummer < 0){
throw new IllegalArgumentException();
}
this.nummer = nummer;
}
/**
* Update de locatie van deze bus
* @param lon: De nieuwe longditude van deze bus
* @param lat: De nieuwe ladditude van deze bus
*/
public void updateLocatie(double lat, double lon) {
this.lat = lat;
this.lon = lon;
}
/**
* Haal het chassisnummer van de bus op
* @return Het nummer van deze bus
*/
public int getNummer(){
return this.nummer;
}
/**
* Vraag de huidige rit van deze bus op
* @return De huidige rit of null als deze bus niet aan een rit bezig is.
*/
public Rit getHuidigeRit(){
return this.huidigeRit;
}
/**
* Zet de huidige rit van deze bus
* @param rit De rit die deze bus gaat maken. Nooit null
*/
public void setHuidigeRit(Rit rit){
this.huidigeRit = rit;
}
/**
* Vraag de coordinaten op van de plek waar deze bus zich momenteel bevind
* @return Een array met hierin de lon en lat. Kan leeg zijn als de coordinaten van deze bus niet gezet zijn
*/
public double[] getCoordinaten(){
double[] cords = {this.lat, this.lon};
return cords;
}
} | maartenpeels/Bus-Tracker | src/com/busenzo/domein/Bus.java | 496 | /**
* Vraag de coordinaten op van de plek waar deze bus zich momenteel bevind
* @return Een array met hierin de lon en lat. Kan leeg zijn als de coordinaten van deze bus niet gezet zijn
*/ | block_comment | nl | package com.busenzo.domein;
public class Bus {
private int nummer;
private double lon;
private double lat;
private Rit huidigeRit;
/**
* Maak een nieuwe bus aan met een specifiek chassisnummer. Er mag nog geen bus bestaan met het gegeven nummer
* @param nummer Het chassisnummer dat deze bus moet krijgen. Altijd groter als 0.
*/
public Bus(int nummer) {
if(nummer < 0){
throw new IllegalArgumentException();
}
this.nummer = nummer;
}
/**
* Update de locatie van deze bus
* @param lon: De nieuwe longditude van deze bus
* @param lat: De nieuwe ladditude van deze bus
*/
public void updateLocatie(double lat, double lon) {
this.lat = lat;
this.lon = lon;
}
/**
* Haal het chassisnummer van de bus op
* @return Het nummer van deze bus
*/
public int getNummer(){
return this.nummer;
}
/**
* Vraag de huidige rit van deze bus op
* @return De huidige rit of null als deze bus niet aan een rit bezig is.
*/
public Rit getHuidigeRit(){
return this.huidigeRit;
}
/**
* Zet de huidige rit van deze bus
* @param rit De rit die deze bus gaat maken. Nooit null
*/
public void setHuidigeRit(Rit rit){
this.huidigeRit = rit;
}
/**
* Vraag de coordinaten<SUF>*/
public double[] getCoordinaten(){
double[] cords = {this.lat, this.lon};
return cords;
}
} |