/ / जावा में कक्षा के एक ऐरे में डुप्लिकेट को अनदेखा करना - जावा, सरणी, डुप्लिकेट, डुप्लिकेट-हटाने

जावा में कक्षा के एक ऐरे में डुप्लिकेट को अनदेखा करना - जावा, सरणी, डुप्लिकेट, डुप्लिकेट हटाने

प्रसंग: मैं एक पोकर प्रोग्राम बनाने की कोशिश कर रहा हूं जो कार्ड के डेक से 5 कार्ड देता है। मेरे पास एक कन्स्ट्रक्टर है जो लूप के लिए यादृच्छिक कार्ड और एक सरणी देता है जो उपयोगकर्ता को 5 कार्ड देने के लिए कन्स्ट्रक्टर को कॉल करता है। हालांकि मुझे नहीं पता कि इसे कैसे सेट अप किया जाए ताकि दो कार्ड्स में समान मूल्य और सूट न हो। अब तक मैंने लूप में डू / लूप डालने का प्रयास नहीं किया है। यह परियोजना का हिस्सा है:

मुख्य वर्ग

public class pokerMain {

public static void main(String[] args) {

Scanner key = new Scanner(System.in);

pokerHand[] card = new pokerHand[5];

System.out.println("Would you like 5 random cards?");

if(key.next().equals("yes"))
{
for(int i = 0; i < 5; i++)
{
card[i] = new pokerHand();
System.out.println(card[i]);
}
}



}

}

और कक्षा जिसमें निर्माता शामिल है

public class pokerHand {

private int value;
private String suit;

//gives a random card
public pokerHand()
{
Random card = new Random();
value = card.nextInt(13) + 1;
int suitNb = card.nextInt(4) + 1;

switch(suitNb)
{
case 1: suit = "hearts"; break;
case 2: suit = "spades"; break;
case 3: suit = "diamonds"; break;
case 4: suit = "clubs"; break;
}

}

उत्तर:

उत्तर № 1 के लिए 1

कार्ड के डेक को लागू करने के लिए यहां कुछ विचार दिए गए हैं।

public enum Suite {
HEARTS, SPADES, CLUBS, DIAMONDS;
}

public enum Value {
ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING, ACE;
}

public class Card
{
private final Suite suite;
private final Value value;

public Card(final Suite suite, final Value value)
{
this.suite = suite;
this.value = value;
}

@Override
public boolean equals(final Object obj)
{
if (this == obj)
{
return true;
}
if (obj == null)
{
return false;
}
if (getClass() != obj.getClass())
{
return false;
}
final Card other = (Card) obj;
if (suite != other.suite)
{
return false;
}
if (value != other.value)
{
return false;
}
return true;
}

@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + ((suite == null) ? 0 : suite.hashCode());
result = prime * result + ((value == null) ? 0 : value.hashCode());
return result;
}

@Override
public String toString()
{
return "[" + value + " of " + suite + "]";
}
}

public class Deck
{
public static void main(final String[] args)
{
final Deck deck = new Deck();
for (int i = 0; i < 5; i++)
{
System.out.println(deck.deal());
}
}

List<Card> cards = new ArrayList<Card>();

public Deck()
{
// initialise
for (final Suite suite : Suite.values())
{
for (final Value value : Value.values())
{
final Card card = new Card(suite, value);
cards.add(card);
}
}
}

public Card deal()
{
final Random random = new Random(System.nanoTime());
if (cards.size() > 0)
{
return cards.remove(random.nextInt(cards.size()));
}
else
{
return null;
}
}

@Override
public String toString()
{
return cards.toString();
}
}

जवाब के लिए 0 № 2

ऐसे कुछ तरीके हैं जिन्हें आप कार्यान्वित कर सकते हैंडुप्लिकेट जांच लेकिन संभवत: ऐसा करने का सबसे साफ तरीका इस तथ्य का लाभ उठाना है कि सेट में डुप्लीकेट नहीं हो सकते हैं। तो सबसे पहले, अपने पोकर में हैशकोड () और बराबर () को ओवरराइड करें (आप देख सकते हैं कि यह कैसे किया जा सकता है, उदाहरण के लिए, में यह प्रश्न)। फिर अपनी मुख्य विधि में, कार्ड को सरणी के बजाय सेट में रखें:

if(key.next().equals("yes"))
{
Set<pokerHand> hands = new HashSet<pokerHands>();
while (hands.size() < 5) {
hands.add(new pokerHand());
}

for (pokerHand hand : hands) {
System.out.println(hand);
}
}

इसमें कोई कमी है, जो यह हैतकनीकी रूप से आपको एक अनंत लूप की संभावना के लिए खुलता है यदि पोकरहैंड कन्स्ट्रक्टर पहले से सेट में मौजूद तत्वों को लौटता रहता है। बेशक अभ्यास में ऐसा तब तक नहीं होगा जब तक आपके पोकर हैंड कन्स्ट्रक्टर यादृच्छिक संयोजनों को सही तरीके से वापस नहीं कर रहा है। अंतर्निहित समस्या यह है कि यह जानना असंभव है कि खिलाड़ी के हाथ में पहले से ही क्या है जब आप एक नया प्लेयर हैंड ऑब्जेक्ट बनाते हैं।