# Erudite Valley: [case] simulated landlords licensing game

Posted by dhimok on Mon, 03 Jan 2022 07:15:12 +0100

### 1. Demand

Use a set object to store a deck of playing cards, disrupt the order of all playing cards, and then distribute them to three players and cards represented by the set, and print the set contents of players and cards.

### 2. Steps

• Buy a deck of playing cards and combine the colors and numbers to generate all ordinary cards. Manually add size King
• Shuffle: use the shuffle() method of the Collections tool class to shuffle the order of cards
• Deal: traverse the deck, distribute each card to three player sets, and leave three cards as cards
• Card reading: print the contents of each player set separately

Analysis 1

• Create numeric array: nums
• Create Decor array: colors
• Loop nested concatenation of two arrays
• Concat method of String class: colors [i] Concat (Num s [J]) (X.concat(Y) outputs XY; Y. Concat (x) counts (the result is YX)
```package cn.itcast.demo2;

public class SendPokerTest {
public static void main(String[] args) {
//Create an array of numbers and decors
String[] nums = {"3","4","5","6","7","8","9","K","Q","J","A","2"};
String[] colors = {"♣","♦","♥","♠"};

//Splice two arrays
for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < colors.length; j++) {
colors[j].concat(nums[i]);
System.out.print(colors[j].concat(nums[i])+" ");

}
}

}
}

```

Analysis 2

• Define a double column set, set the number with the key, and the value indicates the specific card rule: the smaller the number, the smaller the card (how to set the number for cards with different colors and the same size, and why to set the number)
• Define a single column set to store numbers
• Loop nested two arrays, add cards to the double column set, and add numbers to the single column set
• Print
```package cn.itcast.demo2;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class SendPokerTest {
public static void main(String[] args) {
//Create an array of numbers and decors
String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
String[] colors = {"♣","♦","♥","♠"};

//Define a num to represent the number
int num = 0;

//Define a two column set that stores cards and card numbers
Map<Integer,String> pokers = new HashMap<>();

//Define a single column set to store card numbers
List<Integer> list = new ArrayList<>();

//Loop nested concatenation of two arrays
for (String number : numbers) {//External circulation traversal deck
for (String color : colors) {//Inner loop traversal Decor
//Splice two arrays as the values of a two column set
String poker = color + number ;
//Add it to the two column set
pokers.put(num,poker);
//Adds a number to a single column set
//The number will increase by 1 for each addition
num++;

}

}
//Print 52 cards currently generated
System.out.println("The 52 cards in the double row set are:" + pokers);
//Print numbers in a single column set
System.out.println("The current 52 numbers are:" + list);

}
}

```

#### 2.2. shuffle the cards

• Shuffle the cards by using the shuffle () method in the Collections tool class

#### 2.3. Licensing

• Create 4 collection objects, three representing player collection objects and one representing cards collection objects

• Licensing action:

• Take the remainder of the index and 3. If the remainder is 0, the card will be issued to the first player. If the remainder is 1, it will be issued to the second player, and the remainder is 2, it will be issued to the third player

• If only the last three cards are left, they will be stored in the card set object

```if(i >= list.size()-3) {
}
```
• Display board

```package cn.itcast.demo2;

import java.util.*;

public class SendPokerTest {
public static void main(String[] args) {
//Create an array of numbers and decors
String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
String[] colors = {"♣","♦","♥","♠"};

//Define a num to represent the number
int num = 0;

//Define a two column set that stores cards and card numbers
Map<Integer,String> pokers = new HashMap<>();

//Define a single column set to store card numbers
List<Integer> list = new ArrayList<>();

//Loop nested concatenation of two arrays
for (String number : numbers) {//External circulation traversal deck
for (String color : colors) {//Inner loop traversal Decor
//Splice two arrays as the values of a two column set
String poker = color + number ;
//Add it to the two column set
pokers.put(num,poker);
//Adds a number to a single column set
//The number will increase by 1 for each addition
num++;

}

}

pokers.put(num,"Xiao Wang");
pokers.put(num,"king");

//Print all cards
System.out.println("The 54 cards in the double row set are:" + pokers);
//Print numbers in a single column set
System.out.println("54 Number:" + list);

//shuffle the cards
Collections.shuffle(list);
System.out.println("Shuffled number:" + list);

//Licensing
//1. Create 4 collection objects
List<Integer> player1 = new ArrayList<>();
List<Integer> player2 = new ArrayList<>();
List<Integer> player3 = new ArrayList<>();
List<Integer> restPoker = new ArrayList<>();

//2. Traverse the list after disorder and deal cards
for (int i = 0; i < list.size(); i++) {
//Gets the index sequence number in the list
Integer pokerNum = list.get(i);
//Licensing according to index
if (i >= list.size() - 3) {
} else if (i % 3 == 0) {
} else if (i % 3 == 1) {
} else if (i % 3 == 2) {
}
}

System.out.println("player1 :" + player1);
System.out.println("player2 :" + player2);
System.out.println("player3 :" + player3);
System.out.println("restPoker :" + restPoker);

}
}

```

#### 2.4. Look at the cards

Define a way to look at cards

• Arrange the player's cards and cards in order from small to large
• Traverse the single column set, and use the elements in the single column set to obtain the values in the double column set
• Defines a variable length StringBuilder object for splicing strings
• Returns a string with leading and trailing spaces removed
• The method is called in the main method.
```package cn.itcast.demo2;

import java.util.*;

public class SendPokerTest {
public static void main(String[] args) {
//Create an array of numbers and decors
String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
String[] colors = {"♣","♦","♥","♠"};

//Define a num to represent the number
int num = 0;

//Define a two column set that stores cards and card numbers
Map<Integer,String> pokers = new HashMap<>();

//Define a single column set to store card numbers
List<Integer> list = new ArrayList<>();

//Loop nested concatenation of two arrays
for (String number : numbers) {//External circulation traversal deck
for (String color : colors) {//Inner loop traversal Decor
//Splice two arrays as the values of a two column set
String poker = color + number ;
//Add it to the two column set
pokers.put(num,poker);
//Adds a number to a single column set
//The number will increase by 1 for each addition
num++;

}

}

pokers.put(num,"Xiao Wang");
pokers.put(num,"king");

//Print all cards
System.out.println("The 54 cards in the double row set are:" + pokers);
//Print numbers in a single column set
System.out.println("54 Number:" + list);

//shuffle the cards
Collections.shuffle(list);
System.out.println("Shuffled number:" + list);

//Licensing
//1. Create 4 collection objects
List<Integer> player1 = new ArrayList<>();
List<Integer> player2 = new ArrayList<>();
List<Integer> player3 = new ArrayList<>();
List<Integer> restPoker = new ArrayList<>();

//2. Traverse the list after disorder and deal cards
for (int i = 0; i < list.size(); i++) {
//Gets the index sequence number in the list
Integer pokerNum = list.get(i);
//Licensing according to index
if (i >= list.size() - 3) {
} else if (i % 3 == 0) {
} else if (i % 3 == 1) {
} else if (i % 3 == 2) {
}
}

//Output player cards and cards
System.out.println("player1 :" + printPoker(player1,pokers));
System.out.println("player2 :" + printPoker(player2,pokers));
System.out.println("player3 :" + printPoker(player3,pokers));
System.out.println("restPoker :" + printPoker(restPoker,pokers));

}

/*Define a method for watching cards
*  Method name: printPoker()
*  Parameter list: output specific cards according to the number
*   List<Integer> nums, Map<Integer,String> poker*/

public static String printPoker(List<Integer> nums,Map<Integer,String> pokers) {
//Arrange the cards from small to large
Collections.sort(nums);
//Traverse the single column set and obtain the specific cards in the double column set according to the set element number
StringBuilder sb = new StringBuilder();
for (Integer num : nums) {
//Obtain the specific cards in the double column set according to the elements obtained in the list set (i.e. the keys in the double column set)
String eachPoke = pokers.get(num);
//Splice the values of three players and cards in the deck set
sb.append(eachPoke + " ");
}

String str = sb.toString();
return str.trim();
}
}

```

Topics: Java intellij-idea