Question

我有一个小结构-

<script type="text/javascript">

function initMap() {

    var locations = [
         ['Title A', 3.180967,101.715546],
         ['Title B', 3.200848,101.616669],
         ['Title C', 3.147372,101.597443],
         ['Title D', 3.19125,101.710052]
    ];
    var map = new google.maps.Map(document.getElementById('map'), {
         zoom: 12,
         center: new google.maps.LatLng(3.171368,101.653404),
         mapTypeId: google.maps.MapTypeId.ROADMAP
    });

    var infowindow = new google.maps.InfoWindow;

    var marker, i;

    for (i = 0; i < locations.length; i++) {  
        marker = new google.maps.Marker({
             position: new google.maps.LatLng(locations[i][1], locations[i][2]),
             map: map
        });

        google.maps.event.addListener(marker, 'click', (function(marker, i) {
             return function() {
                 infowindow.setContent(locations[i][0]);
                 infowindow.open(map, marker);
             }
        })(marker, i));
    }
}

</script>

<script async defer
        src="https://maps.googleapis.com/maps/api/js?v=3.exp&key=YOURAPIKEY=initMap">
</script>


<style type="text/css">
  #map { height: 400px;
    margin-left:auto;
    margin-right:auto;
    text-align:left;
    width: 80%;}
</style>

<div id="map"></div>

然后我用来初始化纸牌数组

struct Card {
        public string suit;
        public string value;
}

在我的Main（）中，我打电话

Card[] deck = new Card[52];

与构造函数相关的

Deck myDeck = new Deck();

...因此创建了一个包含52张牌的牌组，经我的Console.WriteLine（）确认，该牌组正确地填充了牌组。

我的问题是我还有另外2种方法，公共无效Shuffle（）和公共字符串Deal（），顾名思义，它们分别洗牌并发给顶牌，但是我不知道如何通过牌.suit和deck.value值放入所述方法中。

我尝试初始化构造函数中的Card []数组。所有这些功能都在相同的名称空间和类下。

我也想将构造函数和两个方法保留在代码中，并且不使用其他任何方法，即使我确信还有很多其他的，可能更简单的方法可以做到这一点。

谢谢！

Answer 1

玩这个：

void Main()
{
    var deck = new Deck();
    deck.Shuffle();
    var cards = deck.Deal(1);
    foreach (var card in cards)
    {
        Console.WriteLine($"{card.Value} of {card.Suit}");
    }
}

public struct Card
{
    public Card(string suit, string value)
    {
        this.Suit = suit;
        this.Value = value;
    }
    public readonly string Suit;
    public readonly string Value;
}

public class Deck
{
    private const int _numSuits = 4;
    private const int _numValues = 13;

    private string[] _suits = new [] { "Clubs", "Diamonds", "Hearts", "Spades", };
    private string[] _values = new []
    {
        "Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King",
    };

    private Card[] _deck = new Card[52];

    public Deck()
    {
        _deck =
            _suits
                .SelectMany(s => _values, (s, v) => new Card(s, v))
                .ToArray();
    }

    private Random _random = new Random();
    public void Shuffle()
    {
        _deck = _deck.OrderBy(_ => _random.Next()).ToArray();
    }

    public Card[] Deal(int take)
    {
        var cards = _deck.Take(take).ToArray();
        _deck = _deck.Skip(take).ToArray();
        return cards;
    }
}

Answer 2

卡的通用性更高。它们不仅在甲板上使用。它们也用在手中。而且有些游戏甚至在我不知道名字的其他结构中也有开放牌（对不起，我只知道Star Trek TNG的扑克）。

根据个人经验，我知道很难为“手”或“甲板”设置合适的课程。最后，两者似乎都比Card []的容器要多。因此，使用Card []可能更好/更容易。并且只有一堆静态函数可以初始化完整的Card Deck，随机播放Deck，DrawFrom Deck并将Card []作为参数之一或返回Card实例。请记住，数组本质上是通过引用来处理的，在这里确实有帮助。

至于不随机抽取随机卡的行为，我个人称之为“彩票问题”。我编写了以下示例代码来处理它：

//Create an array. Fill it with Sequential Numbers.
int[] input = new int[20];

for(int i = 0; i < numbers.lenght; i++)
  input[i] = i;

/*Initialise the instances you will need*/
//Use the array to create a list
List<int> DrawableNumbers = new List<int>(input);
List<int> DrawnNumbers = new List<int>();

//Generate a Random Number Generator
Random rng = new Random();

/*Draw 6 from the group*/
while(DrawnNumbers.Count < 6){
  //Get a random Index to move from DrawableNumbers to DrawnNumbers
  int temp = Random.NextInt(DrawableNumbers.Count);
  DrawnNumbers.Add(DrawableNumbers[i]);
  DrawableNumbers.Remove(temp);
}

洗牌的唯一区别是，直到牌用完才停止。

Answer 3

不幸的是，我还不能发表评论：

Random rnd=new Random();
Card[] randomOrder = deck.OrderBy(x => rnd.Next()).ToArray();    
//TODO: you could iterate over the random order and fill your Stack

那应该随机地洗净你的数组。交易应该很简单，您可以选择阵列的随机索引并退还卡片。如果该卡在使用列表或更好的方法处理后应被删除，则在洗牌时可以填充创建StackT>并填充它，然后每次致电时可以Pop下一张卡您的Deal函数。

@enigmativity击败了我，他的解决方案允许一次获取多张卡片。问题是使用堆栈并缓慢将其清空或使用.Take和新数组的最佳实践是什么？-

在构造函数中设置的c＃结构数组

3 个答案: