Java 硬币交换算法
我正在制作一个扑克游戏。在我的应用程序中，我有一个类Java 硬币交换算法,java,algorithm,Java,Algorithm,我正在制作一个扑克游戏。在我的应用程序中，我有一个类芯片组。芯片组基本上是5个整数的数组（每个彩色扑克芯片一个） 如果你能帮我解决这个问题，我将不胜感激 例如： 在使用该算法之前，我有一个芯片组，其数组[0,0,2,1,0]的总和为20。我想付16个单位的钱。使用该算法后，我将拥有尽可能最高效的交换，在这种情况下，该算法将数组更改为[1,2,1,1,0]，该数组的总和也为20，但现在我可以支付16。付款后，芯片组将拥有阵列[0,2,0,0,0] 我希望我的问题是清楚的，如果不是，请留下评论，我会
芯片组芯片组[0,0,2,1,0][1,2,1,1,0]芯片组将拥有阵列[0,2,0,0,0]
我希望我的问题是清楚的，如果不是，请留下评论，我会进一步解释。这是一个编辑，我完全修改了我的答案。
**博弈视角下的问题**
该球员有2个绿色筹码（5分）和1个蓝色筹码（10分）。总共20分。现在玩家想买一个16分的ingame图标。玩家有足够的钱购买物品。所以玩家支付16分，但是他会给商店多少分来正确支付呢
现在，我已经编写了一个工作示例，其中包含了所有已完成的工作
代码
Program.java
import java.util.Arrays;
public class Program {
public static void main(String[] args) {
// Setting up test environment
Player player = new Player("Borrie", new int[]{0,0,0,0, 230});
int itemCost = 16626;
// Pay for item
System.out.printf("First we check if the player can pay with it's current ChipSet");
if (!player.canPayWithChipSet(player.getChips(), 5)) {
if (player.exchangeChips(5)) {
System.out.printf("\n\nThe players ChipSet:" + Arrays.toString(player.getChips().chips));
System.out.printf("\nThe players ChipSet has been succesfully exchanged.");
} else {
System.out.printf("\n\nThe players ChipSet:" + Arrays.toString(player.getChips().chips));
System.out.printf("\nThe players ChipSet was not able to be exchanged.\n");
}
} else {
System.out.printf("\n\nThe player can pay exact with it's original ChipSet. No need to exchange.");
}
}
}
Player.java
import java.util.ArrayList;
import java.util.Arrays;
public class Player {
private String name;
private ChipSet chips;
private int points = 0;
public Player(String name, int[] chips) {
this.name = name;
this.chips = new ChipSet(chips);
this.points = this.chips.getSum();
}
public boolean exchangeChips(int cost) {
ChipSet newChipSet = exchangePlayerChipSet(this.chips.getChips(), cost);
if (newChipSet == null) {
return false;
} else {
this.chips = newChipSet;
return true;
}
}
public ChipSet exchangePlayerChipSet(int[] originalChipValues, int cost) {
ChipSet newChipSet = null;
// Create possible combinations to compare
ArrayList<ChipSet> chipSetCombos = createCombinations(this.chips.getChips());
// Filter the chipset based on if it's able to pay without changing chips
System.out.printf("\n\n---- Filter which of these combinations are able to be payed with without changing chips ----");
ArrayList<ChipSet> filteredCombos = filterCombinations(chipSetCombos, cost);
// Compare the filtered chipsets to determine which one has changed the least
if (!filteredCombos.isEmpty()) {
newChipSet = compareChipSets(originalChipValues, filteredCombos);
}
return newChipSet;
}
private ArrayList<ChipSet> createCombinations(int[] array) {
ArrayList<ChipSet> combos = new ArrayList<>();
int[] startCombo = array;
System.out.printf("Player has " + getTotalPoints(startCombo) + " points in chips.");
System.out.printf("\nPlayer has these chips (WHITE,RED,GREEN,BLUE,BLACK): " + Arrays.toString(startCombo));
while (startCombo[4] != 0) {
startCombo = lowerBlack(startCombo);
if (getTotalPoints(startCombo) == points) {
combos.add(new ChipSet(startCombo));
}
}
while (startCombo[3] != 0) {
startCombo = lowerBlue(startCombo);
if (getTotalPoints(startCombo) == points) {
combos.add(new ChipSet(startCombo));
}
}
while (startCombo[2] != 0) {
startCombo = lowerGreen(startCombo);
if (getTotalPoints(startCombo) == points) {
combos.add(new ChipSet(startCombo));
}
}
while (startCombo[1] != 0) {
startCombo = lowerRed(startCombo);
if (getTotalPoints(startCombo) == points) {
combos.add(new ChipSet(startCombo));
}
}
System.out.printf("\n\n---- Creating variations on the players chips ----");
System.out.printf("\nVariation (all worth " + getTotalPoints(startCombo) + " points):\n");
int teller = 1;
for (ChipSet a : combos) {
System.out.printf("\nCombo " + teller + ": " + Arrays.toString(a.getChips()));
teller++;
}
return combos;
}
private ArrayList<ChipSet> filterCombinations(ArrayList<ChipSet> combinations, int cost) {
ArrayList<ChipSet> filteredChipSet = new ArrayList<>();
combinations.stream().filter((cs) -> (canPayWithChipSet(cs, cost))).forEach((cs) -> {
filteredChipSet.add(cs);
});
return filteredChipSet;
}
// This method has be worked out
public boolean canPayWithChipSet(ChipSet cs, int cost) {
ChipSet csOrig = new ChipSet(cs.chips);
ChipSet csCopy = new ChipSet(cs.chips);
int counterWhite = 0;
int counterRed = 0;
int counterGreen = 0;
int counterBlue = 0;
int counterBlack = 0;
while (20 <= cost && cost > 0 && csOrig.getChips()[4] != 0) {
csOrig.getChips()[4] -= 1;
cost -= 20;
counterBlack++;
}
while (10 <= cost && cost > 0 && csOrig.getChips()[3] != 0) {
csOrig.getChips()[3] -= 1;
cost -= 10;
counterBlue++;
}
while (5 <= cost && cost > 0 && csOrig.getChips()[2] != 0) {
csOrig.getChips()[2] -= 1;
cost -= 5;
counterGreen++;
}
while (2 <= cost && cost > 0 && csOrig.getChips()[1] != 0) {
csOrig.getChips()[1] -= 1;
cost -= 2;
counterRed++;
}
while (1 <= cost && cost > 0 && csOrig.getChips()[0] != 0) {
csOrig.getChips()[0] -= 1;
cost -= 1;
counterWhite++;
}
if (cost == 0){
System.out.printf("\nCombo: %s can pay exact. With %d white, %d red, %d green, %d blue an %d black chips", Arrays.toString(csCopy.chips),counterWhite,counterRed,counterGreen,counterBlue,counterBlack);
return true;
} else {
System.out.printf("\nCombo: %s cannot pay exact.\n\n\n", Arrays.toString(csCopy.chips));
return false;
}
}
private ChipSet compareChipSets(int[] originalChipValues, ArrayList<ChipSet> chipSetCombos) {
ChipSet newChipSet;
int[] chipSetWaardes = originalChipValues; // originele chipset aantal van kleur
int[] chipSetCombosDifferenceValues = new int[chipSetCombos.size()];
int teller = 1;
System.out.printf("\n\n---- Calculate differences between players stack and it's variations ----");
for (ChipSet cs : chipSetCombos) {
int aantalWhite = cs.getChips()[0];
int aantalRed = cs.getChips()[1];
int aantalGreen = cs.getChips()[2];
int aantalBlue = cs.getChips()[3];
int aantalBlack = cs.getChips()[4];
int differenceWhite = Math.abs(chipSetWaardes[0] - aantalWhite);
int differenceRed = Math.abs(chipSetWaardes[1] - aantalRed);
int differenceGreen = Math.abs(chipSetWaardes[2] - aantalGreen);
int differenceBlue = Math.abs(chipSetWaardes[3] - aantalBlue);
int differenceBlack = Math.abs(chipSetWaardes[4] - aantalBlack);
int totalDifference = differenceWhite + differenceRed + differenceGreen + differenceBlue + differenceBlack;
chipSetCombosDifferenceValues[teller - 1] = totalDifference;
System.out.printf("\nCombo " + teller + ": " + Arrays.toString(cs.getChips()) + " = " + totalDifference);
teller++;
}
newChipSet = chipSetCombos.get(smallestValueOfArrayIndex(chipSetCombosDifferenceValues));
System.out.printf("\n\nThe least different ChipSet is: " + Arrays.toString(newChipSet.getChips()) + " ");
return newChipSet;
}
private int smallestValueOfArrayIndex(int[] array) {
int huidigeWaarde = array[0];
int smallestIndex = 0;
for (int j = 1; j < array.length; j++) {
if (array[j] < huidigeWaarde) {
huidigeWaarde = array[j];
smallestIndex = j;
}
}
return smallestIndex;
}
private int[] lowerBlack(int[] array) {
return new int[]{array[0], array[1], array[2], array[3] + 2, array[4] - 1};
}
private int[] lowerBlue(int[] array) {
return new int[]{array[0], array[1], array[2] + 2, array[3] - 1, array[4]};
}
private int[] lowerGreen(int[] array) {
return new int[]{array[0] + 1, array[1] + 2, array[2] - 1, array[3], array[4]};
}
private int[] lowerRed(int[] array) {
return new int[]{array[0] + 2, array[1] - 1, array[2], array[3], array[4]};
}
private int getTotalPoints(int[] array) {
return ((array[0] * 1) + (array[1] * 2) + (array[2] * 5) + (array[3] * 10) + (array[4] * 20));
}
public String getName() {
return this.name;
}
public int getPoints() {
return this.points;
}
public ChipSet getChips() {
return chips;
}
}
import java.util.ArrayList；
导入java.util.array；
公开课选手{
私有字符串名称；
专用芯片组芯片；
私人积分=0；
公共播放器（字符串名称，int[]码）{
this.name=名称；
this.chips=新芯片组（芯片）；
this.points=this.chips.getSum（）；
}
公共布尔交换IP（整数成本）{
ChipSet newChipSet=exchangePlayerChipSet（this.chips.getChips（），cost）；
if（新芯片组==null）{
返回false；
}否则{
this.chips=新芯片组；
返回true；
}
}
公共芯片组exchangePlayerChipSet（int[]原始芯片值，int成本）{
芯片组newChipSet=null；
//创建可能的组合进行比较
ArrayList chipSetCombos=createCombinations（this.chips.getChips（））；
//根据芯片组是否能够在不更换芯片的情况下付款来过滤芯片组
System.out.printf（“\n\n----过滤这些组合中的哪些可以在不改变芯片的情况下付款----”；
ArrayList filteredCombos=过滤器组合（芯片组组合，成本）；
//比较过滤后的芯片组以确定哪一个变化最小
如果（！filteredCombos.isEmpty（））{
新芯片组=比较芯片组（原始芯片值、筛选芯片组）；
}
返回新芯片组；
}
私有ArrayList createCombinations（int[]数组）{
ArrayList组合=新建ArrayList（）；
int[]startCombo=数组；
System.out.printf（“玩家拥有”+getTotalPoints（startCombo）+“芯片点数”）；
System.out.printf（“\n层有这些芯片（白、红、绿、蓝、黑）：”+Arrays.toString（startCombo））；
while（startCombo[4]！=0）{
startCombo=低黑度（startCombo）；
if（getTotalPoints（startCombo）=点）{
添加（新芯片组（startCombo））；
}
}
while（startCombo[3]！=0）{
startCombo=低蓝色（startCombo）；
if（getTotalPoints（startCombo）=点）{
添加（新芯片组（startCombo））；
}
}
while（startCombo[2]！=0）{
startCombo=低绿色（startCombo）；
if（getTotalPoints（startCombo）=点）{
添加（新芯片组（startCombo））；
}
}
while（startCombo[1]！=0）{
startCombo=较低（startCombo）；
if（getTotalPoints（startCombo）=点）{
添加（新芯片组（startCombo））；
}
}
System.out.printf（“\n\n----在播放器芯片上创建变体----”；
System.out.printf（“\n变量（所有值”+getTotalPoints（startCombo）+”点）：\n”）；
int-teller=1；
用于（芯片组a：组合）{
System.out.printf（“\nCombo”+teller+”：“+Arrays.toString（a.getChips（））；
teller++；
}
返回组合；
}
专用ArrayList筛选器组合（ArrayList组合，整数成本）{
ArrayList filteredChipSet=新建ArrayList（）；
compositions.stream（）.filter（（cs）->（可以用芯片组（cs，cost））支付）。forEach（（cs）->{
filteredChipSet.add（cs）；
});
返回filteredChipSet；
}
//这个方法已经制定出来了
公共布尔值可通过芯片组支付（芯片组cs，整数成本）{
芯片组csOrig=新芯片组（cs芯片）；
芯片组csCopy=新芯片组（cs芯片）；
int counterWhite=0；
int反红色=0；
绿色=0；
int counterBlue=0；
int计数器黑色=0；
而（20 0&&csOrig.getChips（）[4]！=0）{
csOrig.getChips（）[4]-=1；
成本-=20；
反黑++；
}
而（10 0&&csOrig.getChips（）[3]！=0）{
csOrig.getChips（）[3]-=1；
成本-=10；
反蓝色++；
}
而（5 0&&csOrig.getChips（）[2]！=0）{
csOrig.getChips（）[2]-=1；
成本-=5；
绿色++；
}
而（2 0&&csOrig.getChips（）[1]！=0）{
csOrig.getChips（）[1]-=1；
成本-=2；
counterRed++；
}
而（10&&csOrig.getChips（）[0]！=0）{
csOrig.getChips（）[0]-=1；
成本-=1；
counterWhite++；
}
如果（成本==0）{
System.out.printf（“\n目标：%s可以用%d个白色、%d个红色、%d个绿色、%d个蓝色和%d个黑色筹码准确支付，”，数组.toString（csCopy.chips），counterWhite，counterRed，co
import java.util.Arrays;
public class Program {
public static void main(String[] args) {
// Setting up test environment
Player player = new Player("Borrie", new int[]{0,0,0,0, 230});
int itemCost = 16626;
// Pay for item
System.out.printf("First we check if the player can pay with it's current ChipSet");
if (!player.canPayWithChipSet(player.getChips(), 5)) {
if (player.exchangeChips(5)) {
System.out.printf("\n\nThe players ChipSet:" + Arrays.toString(player.getChips().chips));
System.out.printf("\nThe players ChipSet has been succesfully exchanged.");
} else {
System.out.printf("\n\nThe players ChipSet:" + Arrays.toString(player.getChips().chips));
System.out.printf("\nThe players ChipSet was not able to be exchanged.\n");
}
} else {
System.out.printf("\n\nThe player can pay exact with it's original ChipSet. No need to exchange.");
}
}
}
import java.util.ArrayList;
import java.util.Arrays;
public class Player {
private String name;
private ChipSet chips;
private int points = 0;
public Player(String name, int[] chips) {
this.name = name;
this.chips = new ChipSet(chips);
this.points = this.chips.getSum();
}
public boolean exchangeChips(int cost) {
ChipSet newChipSet = exchangePlayerChipSet(this.chips.getChips(), cost);
if (newChipSet == null) {
return false;
} else {
this.chips = newChipSet;
return true;
}
}
public ChipSet exchangePlayerChipSet(int[] originalChipValues, int cost) {
ChipSet newChipSet = null;
// Create possible combinations to compare
ArrayList<ChipSet> chipSetCombos = createCombinations(this.chips.getChips());
// Filter the chipset based on if it's able to pay without changing chips
System.out.printf("\n\n---- Filter which of these combinations are able to be payed with without changing chips ----");
ArrayList<ChipSet> filteredCombos = filterCombinations(chipSetCombos, cost);
// Compare the filtered chipsets to determine which one has changed the least
if (!filteredCombos.isEmpty()) {
newChipSet = compareChipSets(originalChipValues, filteredCombos);
}
return newChipSet;
}
private ArrayList<ChipSet> createCombinations(int[] array) {
ArrayList<ChipSet> combos = new ArrayList<>();
int[] startCombo = array;
System.out.printf("Player has " + getTotalPoints(startCombo) + " points in chips.");
System.out.printf("\nPlayer has these chips (WHITE,RED,GREEN,BLUE,BLACK): " + Arrays.toString(startCombo));
while (startCombo[4] != 0) {
startCombo = lowerBlack(startCombo);
if (getTotalPoints(startCombo) == points) {
combos.add(new ChipSet(startCombo));
}
}
while (startCombo[3] != 0) {
startCombo = lowerBlue(startCombo);
if (getTotalPoints(startCombo) == points) {
combos.add(new ChipSet(startCombo));
}
}
while (startCombo[2] != 0) {
startCombo = lowerGreen(startCombo);
if (getTotalPoints(startCombo) == points) {
combos.add(new ChipSet(startCombo));
}
}
while (startCombo[1] != 0) {
startCombo = lowerRed(startCombo);
if (getTotalPoints(startCombo) == points) {
combos.add(new ChipSet(startCombo));
}
}
System.out.printf("\n\n---- Creating variations on the players chips ----");
System.out.printf("\nVariation (all worth " + getTotalPoints(startCombo) + " points):\n");
int teller = 1;
for (ChipSet a : combos) {
System.out.printf("\nCombo " + teller + ": " + Arrays.toString(a.getChips()));
teller++;
}
return combos;
}
private ArrayList<ChipSet> filterCombinations(ArrayList<ChipSet> combinations, int cost) {
ArrayList<ChipSet> filteredChipSet = new ArrayList<>();
combinations.stream().filter((cs) -> (canPayWithChipSet(cs, cost))).forEach((cs) -> {
filteredChipSet.add(cs);
});
return filteredChipSet;
}
// This method has be worked out
public boolean canPayWithChipSet(ChipSet cs, int cost) {
ChipSet csOrig = new ChipSet(cs.chips);
ChipSet csCopy = new ChipSet(cs.chips);
int counterWhite = 0;
int counterRed = 0;
int counterGreen = 0;
int counterBlue = 0;
int counterBlack = 0;
while (20 <= cost && cost > 0 && csOrig.getChips()[4] != 0) {
csOrig.getChips()[4] -= 1;
cost -= 20;
counterBlack++;
}
while (10 <= cost && cost > 0 && csOrig.getChips()[3] != 0) {
csOrig.getChips()[3] -= 1;
cost -= 10;
counterBlue++;
}
while (5 <= cost && cost > 0 && csOrig.getChips()[2] != 0) {
csOrig.getChips()[2] -= 1;
cost -= 5;
counterGreen++;
}
while (2 <= cost && cost > 0 && csOrig.getChips()[1] != 0) {
csOrig.getChips()[1] -= 1;
cost -= 2;
counterRed++;
}
while (1 <= cost && cost > 0 && csOrig.getChips()[0] != 0) {
csOrig.getChips()[0] -= 1;
cost -= 1;
counterWhite++;
}
if (cost == 0){
System.out.printf("\nCombo: %s can pay exact. With %d white, %d red, %d green, %d blue an %d black chips", Arrays.toString(csCopy.chips),counterWhite,counterRed,counterGreen,counterBlue,counterBlack);
return true;
} else {
System.out.printf("\nCombo: %s cannot pay exact.\n\n\n", Arrays.toString(csCopy.chips));
return false;
}
}
private ChipSet compareChipSets(int[] originalChipValues, ArrayList<ChipSet> chipSetCombos) {
ChipSet newChipSet;
int[] chipSetWaardes = originalChipValues; // originele chipset aantal van kleur
int[] chipSetCombosDifferenceValues = new int[chipSetCombos.size()];
int teller = 1;
System.out.printf("\n\n---- Calculate differences between players stack and it's variations ----");
for (ChipSet cs : chipSetCombos) {
int aantalWhite = cs.getChips()[0];
int aantalRed = cs.getChips()[1];
int aantalGreen = cs.getChips()[2];
int aantalBlue = cs.getChips()[3];
int aantalBlack = cs.getChips()[4];
int differenceWhite = Math.abs(chipSetWaardes[0] - aantalWhite);
int differenceRed = Math.abs(chipSetWaardes[1] - aantalRed);
int differenceGreen = Math.abs(chipSetWaardes[2] - aantalGreen);
int differenceBlue = Math.abs(chipSetWaardes[3] - aantalBlue);
int differenceBlack = Math.abs(chipSetWaardes[4] - aantalBlack);
int totalDifference = differenceWhite + differenceRed + differenceGreen + differenceBlue + differenceBlack;
chipSetCombosDifferenceValues[teller - 1] = totalDifference;
System.out.printf("\nCombo " + teller + ": " + Arrays.toString(cs.getChips()) + " = " + totalDifference);
teller++;
}
newChipSet = chipSetCombos.get(smallestValueOfArrayIndex(chipSetCombosDifferenceValues));
System.out.printf("\n\nThe least different ChipSet is: " + Arrays.toString(newChipSet.getChips()) + " ");
return newChipSet;
}
private int smallestValueOfArrayIndex(int[] array) {
int huidigeWaarde = array[0];
int smallestIndex = 0;
for (int j = 1; j < array.length; j++) {
if (array[j] < huidigeWaarde) {
huidigeWaarde = array[j];
smallestIndex = j;
}
}
return smallestIndex;
}
private int[] lowerBlack(int[] array) {
return new int[]{array[0], array[1], array[2], array[3] + 2, array[4] - 1};
}
private int[] lowerBlue(int[] array) {
return new int[]{array[0], array[1], array[2] + 2, array[3] - 1, array[4]};
}
private int[] lowerGreen(int[] array) {
return new int[]{array[0] + 1, array[1] + 2, array[2] - 1, array[3], array[4]};
}
private int[] lowerRed(int[] array) {
return new int[]{array[0] + 2, array[1] - 1, array[2], array[3], array[4]};
}
private int getTotalPoints(int[] array) {
return ((array[0] * 1) + (array[1] * 2) + (array[2] * 5) + (array[3] * 10) + (array[4] * 20));
}
public String getName() {
return this.name;
}
public int getPoints() {
return this.points;
}
public ChipSet getChips() {
return chips;
}
}
public class ChipSet {
public static final int WHITE_VALUE = 1;
public static final int RED_VALUE = 2;
public static final int GREEN_VALUE = 5;
public static final int BLUE_VALUE = 10;
public static final int BLACK_VALUE = 20;
public static final int[] VALUES = new int[]{WHITE_VALUE, RED_VALUE, GREEN_VALUE, BLUE_VALUE, BLACK_VALUE};
protected int[] chips;
public ChipSet(int[] chips) {
if (chips == null || chips.length != 5) {
throw new IllegalArgumentException("ChipSets should contain exactly 5 integers!");
}
// store a copy of passed array
this.chips = new int[5];
for (int i = 0; i < this.chips.length; i++) {
this.chips[i] = chips[i];
}
}
public int getSum() {
return chips[0] * WHITE_VALUE
+ chips[1] * RED_VALUE
+ chips[2] * GREEN_VALUE
+ chips[3] * BLUE_VALUE
+ chips[4] * BLACK_VALUE;
}
public int[] getChips() {
return this.chips;
}
}