Programmieren lernen

  int[] karten;
   
  void start() {
    initialisieren();
    mischen();
    verteilen(); }

  void verteilen() {
    int spieler   = 4;
    int aktKarte  = 1;
    int stapelPos = 0;
    while(aktKarte <= 5) {
      int aktSpieler = 0;
      while(aktSpieler < spieler) {
        ausgabe(aktSpieler, stapelPos);
        stapelPos  = stapelPos + 1;
        aktSpieler = aktSpieler + 1;  }
      aktKarte = aktKarte + 1; }
  }

  void ausgabe(int aktSpieler, int stapelPos) {
    System.out.println(
      "Spieler " + aktSpieler +
      " erhaelt die Karte " + 
      kartenName(karten[stapelPos]));  }

  String[] farbNamen = {"Herz",  "Pik",  "Karo", "Kreuz"};
  String[] figurName = {"Junge", "Dame", "Koenig"};
    
  String kartenName(int kartenID) {
   if(kartenID > 52) {
     return "Joker"; }
   int kartenFarbe =  (kartenID - 1) / 13;
   int kartenWert  = ((kartenID - 1) % 13) + 1;
   if(kartenWert > 10) {
     return farbNamen[kartenFarbe] + " " 
            + figurName[kartenWert - 11]; }
   else {
      return farbNamen[kartenFarbe] + " " + kartenWert; } 
  }

  void mischen() {
    int mischenAbPos = 0;
    while(mischenAbPos < karten.length - 1) {
      int zufallsPos = zufall(mischenAbPos, karten.length - 1);
      vertausche(mischenAbPos, zufallsPos);
      mischenAbPos = mischenAbPos + 1; }
  }

  void initialisieren() {
    karten = new int[55];
    int pos;
    pos = 0;
    while(pos < karten.length){
      karten[pos] = pos + 1;
      pos         = pos + 1; }
  }

 void vertausche(int a, int b) {
    int tmpKarte = karten[a];
    karten[a]    = karten[b];
    karten[b]    = tmpKarte; }

  int zufall(int start, int end) {
    return (int) (Math.random() * (end - start + 1)) + start; }

 

                

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Poker verteilen
https://www.programmieraufgaben.ch/aufgabe/poker-verteilen/i4si4ts5
"""

# Programmieraufgabe:
#     Schreiben Sie ein Programm, das vier Spielerinnen je fünf Pokerkarten verteilt.
#     Dabei ist ein Array zunächst mit den Zahlen 1 bis 55 zu füllen. Am einfachsten
#     verwenden Sie dazu die Indizes 1 bis 55. 1-13 entspricht den Herz-Karten,
#     14-26 sind die Pik-Karten, danach folgen 13 Karo- und zuletzt die Kreuz-Karten.
#     Die Nummern 53, 54 und 55 sind die drei Joker-Karten. Die erste bis und mit
#     die zehnte Karte pro Farbe sind jeweils die Zahl-Karten, die elfte entspricht
#     dem Jungen (J), die zwölfte der Queen (Q = Dame) und die dreizehnte. ist der
#     König (K).
#     Mischen Sie den Array nach folgendem Algorithmus (D. Knuth: The Art of
#     Computer Programming Vol. 2; ISBN 0-201-89684-2; Addison-Wesley; S. 145
#     Shuffling) und verteilen Sie die ersten 20 Karten reihum an vier Spielende.
#     Misch-Algorithmus:
#         mischenAbPos := 1
#         while(mischenAbPos < 55)
#         {
#           zufallsPos   := zufällige Position aus den Zahlen [mischenAbPos bis 55]
#           vertausche die Elemente "array[mischenAbPos]" mit "array[zufallsPos]"
#           mischenAbPos := mischenAbPos + 1
#         }
#
# Autor, Erstellung:
#     Ulrich Berntien, 2018-08-31
#
# Sprache:
#     Python 3.6.6


from typing import *
import random


class Karte:
    """
    Eine Spielkarte.
    Alle Spielkarten sind mit einem Code 1 .. 55 versehen über den die Karte erzeugt wird.
    """

    def __init__(self, code: int) -> None:
        """
        Eine Karte mit gegebenen Code erzeugen.
        :param code: Code der Karte, Bereich 1 .. 54.
        """
        assert 1 <= code <= 55
        self._code: int = code

    @property
    def code(self) -> int:
        """
        Der Code der Karte.
        :return: Der Code der Karte.
        """
        return self._code

    def __eq__(self, other) -> bool:
        """
        Vergleichsoperator.
        :param other: Mit diesem Objekt wird verglichen.
        :return: True, genau dann, wenn die Karten den gleichen Code haben.
        """
        return isinstance(self, other.__class__) and self._code == other.code

    def __repr__(self) -> str:
        """
        Darstellung der Karte.
        :return: Name der Karte.
        """
        assert 1 <= self._code <= 55
        assert len(self._wert_name) == 13
        if self._code <= 52:
            return self._gruppen_name[(self._code - 1) // 13] + " " + self._wert_name[(self._code - 1) % 13]
        else:
            return "Joker"

    # Namen der Kartengruppen. Jede Gruppe enthält 13 Werte
    _gruppen_name: Tuple[str, ...] = ("Herz", "Pik", "Karo", "Kreuz")

    # Namen der 13 Werte
    _wert_name: Tuple[str, ...] = tuple(str(i) for i in range(1, 11)) + ("Junge", "Dame", "König")


def riffle(block: List) -> None:
    """
    Mischen einer Liste mit dem gegebenen Algorithmus.
    :param block: Der Inhalt dieser Liste wird gemischt.
    """
    for index_a in range(len(block)):
        index_b = random.randrange(index_a, len(block))
        assert index_a <= index_b < len(block)
        block[index_a], block[index_b] = block[index_b], block[index_a]


kartenspiel = [Karte(i) for i in range(1, 56)]
print(kartenspiel)
riffle(kartenspiel)
# Kontrolle: Alle Karten sind noch im Spiel
assert all(Karte(i) in kartenspiel for i in range(1, 56))
# Kontrolle: Die Anzahl der Karten stimmt noch, also kann keine Karte doppelt sein.
assert len(kartenspiel) == 55
for person in range(4):
    print("Karten für Person {}:".format(person + 1), kartenspiel[person * 5:person * 5 + 5])
                

Lösung von: Ulrich Berntien ()

/*
 *  Programmieraufgabe: Poker verteilen
 *  https://www.programmieraufgaben.ch/aufgabe/poker-verteilen/i4si4ts5
 */


/**
 *  Eine Spielkarte.
 *  Alle Spielkarten sind mit einem Code 1 .. 55 versehen, der beim Erzeugen
 *  der Karte vergeben wird. Die Codes sind in der Aufgabe definiert.
 */
 data class Card(private val code: Int) {

    private companion object {
        /**
         *  Namen der Kartengruppen.
         *  Es gibt 4 Gruppen.
         */
        val gruppenName = arrayOf("Herz", "Pik", "Karo", "Kreuz")

        /**
         *  Namen der Werte.
         *  In jeder der 4 Gruppen gibt es 13 Werte.
         */
        val wertName = Array(10) { (it + 1).toString() } + arrayOf("Junge", "Dame", "König")
    }

    init {
        assert(code in 1..55)
        assert(gruppenName.size == 4)
        assert(wertName.size == 13)
    }

    /**
     *  Name der Karte.
     *  Es gibt 13 Karten in jeder Gruppe (4*13=52) dazu 3 Joker (4*13+3=55)
     *  @return Name der Karte.
     */
    override fun toString() =
            if (code <= 52) "${gruppenName[(code - 1) / 13]} ${wertName[(code - 1) % 13]}" else "Joker"
}


/**
 *  Mischen der Werte im Array.
 *  @param array Die Werte in diesem Array werden gemischt.
 */
fun <T> riffle(array: Array<T>) {
    for (indexA in array.indices) {
        val indexB = (Math.random() * array.size).toInt()
        val temp = array[indexA]
        array[indexA] = array[indexB]
        array[indexB] = temp
    }
}


/**
 * Spielkarten an 4 Personen verteilen.
 */
fun main(args: Array<String>) {
    val cardSet = Array(55) { Card(it + 1) }
    println( "alle Karten: ${cardSet.contentToString()}" )
    riffle(cardSet)
    // Kontrolle: Alle Karten sind noch im Spiel
    assert((1..55).all { Card(it) in cardSet })
    // Kontrolle: Die Anzahl der Karten stimmt noch, also kann keine Karte doppelt sein.
    assert(cardSet.size == 55)
    for (person in 1..4) {
        val personCardSet = cardSet.sliceArray(person * 5 - 5 until person * 5)
        // Kontrolle: Es werden 5 Karten gegeben.
        assert(personCardSet.size == 5)
        println("Karten für Person $person: ${personCardSet.contentToString()}")
    }
}

                

Lösung von: Ulrich Berntien ()

function DeckOfCards() {
  this.cards = [];
  for (let i = 127137; i <= 127199; i++)
    this.cards.push(String.fromCharCode(i));
  this.shuffle = function() {
    for (i = 0; i <= 54; i++) {
      let rndPos = Math.floor(Math.random() * 55);
      let tmp = this.cards[i];
      this.cards[i] = this.cards[rndPos];
      this.cards[rndPos] = tmp;
    }
  }
  this.pickUp = function() {
    return this.cards.shift();
  }
}

let deck = new DeckOfCards();
deck.shuffle();

let players = [
  { name: 'Anna', hand: [] },
  { name: 'Bernd', hand: [] },
  { name: 'Carlotta', hand: [] },
  { name: 'Dieter', hand: [] }
];

// karten geben
for (let i = 1; i <= 5; i++) {
  for (let j = 0; j <= 3; j++) {
    players[j].hand.push(deck.pickUp());
  }
}

// der tisch
for (i = 0; i <= 3; i++)
  document.write(`<div id="${players[i].name}">
  ${players[i].hand.join(', ')}</div>`);                     // lissalanda@gmx.at

                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

// NET 6.x | C# 10.x | VS-2022

var numberOfPlayers = 4;
var numberOfCards = 5;
if (numberOfPlayers is < 2 or > 6 || numberOfCards is < 2 or > 5) return;

// Kartendeck erstellen
var values = new List<string> { "2", "3", "4", "5", "6", "7", "8", "9", "10", "Bube", "Dame", "Koenig", "As" };
var suits = new List<string> { "Kreuz", "Pik", "Herz", "Karo" };
var cardDeck = suits.Select(x => values.Select(y => (suit: x, value: y))).SelectMany(x => x).ToList();

// Karten mischen
var shuffledDeck = cardDeck.OrderBy(x => Guid.NewGuid()).ToList();

// Spieler anlegen
var players = new List<Player>();
for (int i = 0; i < numberOfPlayers; i++)
    players.Add(new Player($"Player{i + 1}", new List<(string, string)>()));

// Karten reihum an die Spieler verteilen
for (int i = 0; i < numberOfPlayers * numberOfCards; i++)
    players[i % numberOfPlayers].Cards.Add(shuffledDeck[i]);

// Karten auf der Hand sortiert anzeigen
for (int i = 0; i < numberOfPlayers; i++)
    Console.WriteLine($"{players[i].Name}: {string.Join(", ", players[i].Cards.OrderBy(x => -values.IndexOf(x.value)).ThenBy(x => suits.IndexOf(x.suit)))}");

record class Player(string Name, List<(string suit, string value)> Cards);
                

Lösung von: Jens Kelm (@JKooP)

#include <iostream>
#include <vector>
#include <random>
#include <chrono>

struct Player {
    std::string name;
    std::vector<std::string> cards;
};

int main()
{
    // Benennung der Karten ist variabel (auch deutsches Blatt möglich)
    std::vector<std::string> values{ "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A" };
    std::vector<std::string> suits{ "C", "S", "H", "D" };
    std::vector<std::string> card_deck{};

    // Kartendeck erstellen
    for (const auto& v : values)
        for (const auto& s : suits)
            card_deck.push_back(s + v);

    // Karten mischen
    auto s{ (int)std::chrono::system_clock::now().time_since_epoch().count() };
    auto r{ std::default_random_engine(s) };
    shuffle(card_deck.begin(), card_deck.end(), r);

    // Spieler anlegen
    Player p1, p2, p3, p4;

    std::vector<Player> players{
        { p1.name = "Player1", p1.cards = {} },
        { p2.name = "Player2", p2.cards = {} },
        { p3.name = "Player3", p3.cards = {} },
        { p4.name = "Player4", p4.cards = {} }
    };

    // Karten an Spieler reihum verteilen
    for (auto i{ 0 }; i < 20; i++)
        players[i % 4].cards.push_back(card_deck[i]);

    // Karten der Spieler zeigen
    for (const auto& p : players) {
        std::cout << p.name << ": ";
        for (const auto& c : p.cards)
            std::cout << c << ", ";
        std::cout << std::endl;
    }
}
                

Lösung von: Jens Kelm (@JKooP)

// C++20 | VS-2022

#include <algorithm>
#include <iostream>
#include <random>
#include <ranges>
#include <string>
#include <vector>

struct Card {
    std::string value;
    std::string suit;

    static friend std::ostream& operator<<(std::ostream& os, const Card& card) {
        return os << card.suit << card.value;
    }
};
struct Player {
    std::string name;
    std::vector<Card> cards;
};

class Poker {
private:
    const size_t MIN_PLAYER{ 2 };
    const size_t MAX_PLAYER{ 6 };
    const size_t NUM_OF_CARDS{ 5 };
    const size_t NUM_OF_PLAYERS{ 4 };
    const std::vector<std::string> VALUES{ " 2", " 3", " 4", " 5", " 6", " 7", " 8", " 9", "10", " B", " D", " K", " A" };
    const std::vector<std::string> SUITS{ "Ka ", "Hz ", "Pi ", "Kr " };

    size_t num_of_players_{ NUM_OF_PLAYERS };
    bool sorted_{ true };
    std::vector<Card> card_deck_{};
    std::vector<Player> players_{};
    std::random_device rd_;

    void set_card_deck();
    void set_players();
    void set_hands();
    void shuffle_deck();
    void execute();

public:
    Poker() { execute(); };
    Poker(size_t num_of_players, bool sorted = true) {
        if (num_of_players < MIN_PLAYER) num_of_players_ = MIN_PLAYER;
        else if (num_of_players > MAX_PLAYER) num_of_players_ = MAX_PLAYER;
        else num_of_players_ = num_of_players;
        sorted_ = sorted;
        execute();
    }
    friend std::ostream& operator<<(std::ostream&, const Poker&);
};

void Poker::set_card_deck() {
    for (const auto& value : VALUES)
        for (const auto& suit : SUITS)
            card_deck_.push_back({ value, suit });
}

void Poker::set_players() {
    for (auto i{ 0 }; i < num_of_players_; ++i)
        players_.push_back({ ("Player " + std::to_string(i + 1)), {} });
}

void Poker::set_hands() {
    for (auto i{ 0 }; i < (num_of_players_ * NUM_OF_CARDS); ++i)
        players_.at(i % num_of_players_).cards.push_back(card_deck_.at(i));
}

void Poker::shuffle_deck() {
    std::ranges::shuffle(card_deck_, rd_);
}

void Poker::execute() {
    set_card_deck();
    shuffle_deck();
    set_players();
    set_hands();
}

std::ostream& operator<<(std::ostream & os, const Poker & pok) {
    const auto greater{ [](const Card& lhs, const Card& rhs) { return lhs.value > rhs.value; } };
    for (auto [name, cards] : pok.players_) {
        os << name << ": ";
        if (pok.sorted_) std::ranges::sort(cards, greater);
        for (const auto& card : cards)
            os << card << " | ";
        os << std::endl;
    }
    return os;
}

int main() {
    std::cout << Poker();
}



                

Lösung von: Jens Kelm (@JKooP)