Programmieren lernen

import random
def poker():
    f=[]
    h=[0,0,0,0,0,0,0]
    m=[0,0,0,0,0,0]
    for i in range(5):
        f.append(random.randint(1, 6))
    print f    

    for z in f:
        h[z]+=1

    for a in h:
        m[a]+=1
        
    ss ='nichts zählbares'
    if m[5]:
        ss = 'alle sind gleich'
    if m[4]:
        ss = 'vier gleiche'
    if m[3]:
        ss = 'drei gleiche'
    if (m[3]&m[2]):
        ss = 'full house'
    if m[2]:    
        ss = str(m[2]) + ' Paar'
    if h==[0,1,1,1,1,1,0]or h==[0,0,1,1,1,1,1]:
        ss = '!!!!!!!!!! Reihe !!!!!!'
    return ss

for i in range(100):
    print poker()
                

let cast = function() {
  let out = [];
  for (let i = 0; i < 5; i++)
    out[i] = Math.floor((Math.random() * 6) + 1);
  return out;
}

function checkCast(cast) {
  let pattern = [0, 0, 0, 0, 0, 0];
  for (let i = 0; i <= cast.length; i++) pattern[cast[i]-1]++;
  pattern.sort().reverse();
  switch (pattern[0]) {
    case 5 : return 'Poker5';
    case 4 : return 'Poker4';
    case 3 :
      if (pattern[1] == 2) return 'Full House';
      else return 'Tripel';
    case 2 :
      if (pattern[1] == 2) return 'Doppelpaar';
       else return 'Paar';
    case 1 :
      let c = cast.join('');
      if (c == '12345' || c == '23456') return 'Straße';
  }
  return 'Glück in der Liebe';
}

let c = cast();
console.log(`${c.sort()}: ${checkCast(c)}`);                 // lissalanda@gmx.at
                

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

// NET 7.x | C# 11.x | VS-2022
var lstDice = Enumerable.Range(0, 5).Select(x => new Random().Next(1, 7)).OrderBy(x => x).ToList();
Console.WriteLine($"Wurf: {string.Join(", ", lstDice)}\n");

var grouped = lstDice.GroupBy(x => x).Select(x => (n: x.Key, c: x.Count())).ToList();
var isXofKind = (int p) => grouped.Any(x => x.c >= p);

// Ausgabe aller möglichen Gewinne
Console.WriteLine($"Poker 5:    {isXofKind(5)}");
Console.WriteLine($"Poker 4:    {isXofKind(4)}");
Console.WriteLine($"Full House: {isXofKind(3) && isXofKind(2)}");
Console.WriteLine($"Tripel:     {isXofKind(3)}");
Console.WriteLine($"Doppelpaar: {grouped.Where(x => x.c >= 2).Count() == 2}");
Console.WriteLine($"Paar:       {isXofKind(2)}");
Console.WriteLine($"Strasse:    {string.Join("", lstDice) is "12345" or "23456"}");
                

Lösung von: Jens Kelm (@JKooP)

// C++ 14 | VS-2022
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>

// Gruppieren der Würfel nach Augenzahl
template<typename Ty_>
const auto get_grouped_vector(const std::vector<Ty_>& vector) {
    std::map<Ty_, size_t> out;
    for (const auto& elem : vector)
        if (out.count(elem)) out[elem]++;
        else out.emplace(elem, 1);
    return out;
}

// Gewinnermittlung ohne Strasse
template<typename Ty_, typename Pa_>
const auto is_x_of_kind(const Ty_& container, const Pa_& param) {
    return std::count_if(container.begin(), container.end(), [&param](auto x) { return x.second >= param; });
}

// Gewinnermittlung Strasse
template<typename Ty_>
const auto is_straight(Ty_ container) {
    Ty_ s1{ 1,2,3,4,5 }, s2{ 2,3,4,5,6 };
    return s1 == container || s2 == container;
}

// sortierte Ausgabe nach Augenzahl
template<typename Ty_>
const std::ostream& print(std::ostream& os, const std::vector<Ty_>& vector, const char* delimiter = ", ") {
    for (auto it{ vector.begin() }; it != vector.end() - 1; ++it)
        std::cout << *it << delimiter;
    std::cout << vector.back() << "\n";
    return os;
}

// Ausgabe der Gewinne
template<typename Ty_>
const std::ostream& print(std::ostream& os, const Ty_& container, bool result) {
    os << container << ": " << (result ? "Ja" : "Nein") << "\n";
    return os;
}

// Würfeln und Sortieren
const auto get_dice_result() {
    std::vector<size_t> v{};
    for (size_t i{ 0 }; i < 5; ++i) v.push_back(rand() % 6 + 1);
    std::sort(v.rbegin(), v.rend());
    return v;
}

int main() {
    srand((int)time(nullptr));

    const auto res{ get_dice_result() };

    std::cout << "Wurf: "; print(std::cout, res);

    const auto grp{ get_grouped_vector(res) };

    // Ausgabe aller möglichen Gewinne
    print(std::cout, "Poker 5", is_x_of_kind(grp, 5));
    print(std::cout, "Poker 4", is_x_of_kind(grp, 4));
    print(std::cout, "Full House", is_x_of_kind(grp, 3) && is_x_of_kind(grp, 2));
    print(std::cout, "Tripel", is_x_of_kind(grp, 3));
    print(std::cout, "Doppelpaar", is_x_of_kind(grp, 2) == 2);
    print(std::cout, "Paar", is_x_of_kind(grp, 2));
    print(std::cout, "Strasse", is_straight(res));
}
                

Lösung von: Jens Kelm (@JKooP)