Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Schach 960 (Anweisungen und Abfolgen)

Schach 960 ist eine Variante des Schachspiels mit veränderter Ausgangstellung, in der die Reihe der Figuren hinter den Bauern für jede Partie neu definiert wird um Routinezüge zu verhindern und den Spieler dazu bringt, außerhalb des üblichen Rahmens zu denken.

Deine Aufgabe: Erstelle einen Algorithmus, der eine zufällige aber gültige Chess960-Ausgangsstellung vorgibt.
Akzeptierte Ausgabeformate sind ausschließlich PGN u/o eine illustrierte Zeile der untersten Reihe eines Spielers.

0 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

6 Lösung(en)

// C++ 17
#include <iostream>
#include <vector>

// Ausgabe aller 960 Möglichkeiten

int main() {
    std::vector<std::string> p{ "Q", "K", "B1", "B2", "N", "N", "R1", "R2"};
    std::sort(p.begin(), p.end());
    auto c{ 0 };
    while (next_permutation(p.begin(), p.end())) {
        const auto idx{ [&p](const std::string& s) { const auto f{ std::find(p.begin(), p.end(), s) }; return f != p.end() ? f - p.begin() : -1; } };
        const auto pos_k{ idx("K") };
        if (pos_k > 0 && pos_k < 7 && idx("R1") < pos_k && idx("R2") > pos_k && idx("B1") % 2 == 0 && idx("B2") % 2 != 0) {
            for (const auto& i : p) std::cout << i.substr(0, 1) << " ";
            std::cout << "\n";
            c++;
        }
    }
    std::cout << "Anzahl aller Moeglichkeiten: " << c << "\n";
}
                

Lösung von: Jens Kelm (@JKooP)

// NET 6.x | C# 10.x | VS-2022
// Ausgabe aller 960 Möglichkeiten

new Permutation().Permute(new List<string> { "Q", "K", "B1", "B2", "N", "N", "R1", "R2" });

public class Permutation {
    public void Permute(List<string> lst) => Permute(lst, 0, lst.Count - 1);
    private void Permute(List<string> lst, int k, int m) {
        if (k == m) {
            var pos_k = lst.IndexOf("K");
            if (pos_k is > 0 and < 7 &&
                lst.IndexOf("R1") < pos_k && lst.IndexOf("R2") > pos_k &&
                lst.IndexOf("B1") % 2 == 0 && lst.IndexOf("B2") % 2 != 0)
                Console.WriteLine(string.Join(" | ", lst.Select(x => x[..1])));
        }
        else
            for (int i = k; i <= m; i++) {
                (lst[k], lst[i]) = (lst[i], lst[k]);
                Permute(lst, k + 1, m);
                (lst[k], lst[i]) = (lst[i], lst[k]);
            }
    }
}
                

Lösung von: Jens Kelm (@JKooP)

from random import randint;from itertools import permutations
print(list(set([''.join([i[0] for i in a]) for a in list(permutations(['K','D','T1','T2','S','S','L1','L2'])) if (a.index('L1')+a.index('L2')) %2 !=0 and (a.index('T1')<a.index('K')<a.index('T2') or a.index('T2')<a.index('K')<a.index('T1'))]))[randint(0,959)])
                

Lösung von: rob ert (tub)

/**********************************************************************\
|* Umsetzung der würfelmethode nach I. Altendörfer                    *|
|* ------------------------------------------------------------------ *|
|* Mögliche werte für §output:                                        *|
|*                                                                    *|
|* - 'utc' (standard):                                                *|
|*   ausgabe der weißen startreihe als unicode-symbole                *|
|*   (bleib tapfer, programmieraufgaben.ch, da musst du jetzt durch!) *|
|*                                                                    *|
|* - 'asc':                                                           *|
|*   ausgabe der weißen startreihe als ascii-abkürzungen              *|
|*                                                                    *|
|* - 'fen'                                                            *|
|*   ausgabe des bretts in Forsythe-Edwards-notation                  *|
\**********************************************************************/

function chess960startPos(output = 'utc') {
  let row = new Array(8),
      i;
  // würfelmethode
  function d(num) { return Math.floor(Math.random() * ++num) }
  // leere felder
  function empties() {
    let arr = [];
    for (let i = 0; i < 8; i++)
      if (row[i] == undefined) arr.push(i);
    return arr;
  }
  // läufer auf zufälliges schwarzes feld
  row[d(2) * 2] = '?';
  // läufer auf zufälliges weißes feld
  row[d(2) * 2 + 1] = '?';
  // dame auf zufälliges leeres feld
  row[empties()[d(5)]] = '?';
  // springer 1 auf zufälliges leeres feld
  row[empties()[d(4)]] = '?';
  // springer 2 auf zufälliges leeres feld
  row[empties()[d(3)]] = '?';
  // türme und könig auf die restlichen felder,
  // könig in die mitte
  for (i = 1; i <= 3; i++) row[empties()[0]] = i==2 ? '?' : '?';

  // $output = 'utc';
  if (output == 'utc') return row;

  // $output = 'asc'
  for (i = 0; i < row.length; i++)
    switch(row[i]) {
      case '?': row[i] = 'R'; break;
      case '?': row[i] = 'N'; break;
      case '?': row[i] = 'B'; break;
      case '?': row[i] = 'Q'; break;
      case '?': row[i] = 'K'; break;
  }
  if (output == 'asc') return row;

  // $output = 'fen'
  return row.join('').toLowerCase()
    + '/pppppppp/8/8/8/8/PPPPPPPP/'
    + row.join('') + 'w AHah - 0 1';
}

console.log( chess960startPos().join('|') );
console.log( chess960startPos('asc').join('') );
console.log( chess960startPos('fen') );

                

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

// NET 7.x | C# 11.x | VS-2022
// Hier für eine zufällige Ausgangsstellung

// leere Felder ermitteln
static IEnumerable<int> GetEmpties(char[] arr) {
    for (var i = 0; i < arr.Length; i++)
        if (arr[i] == '\0') yield return i;
}

var rnd = new Random();
var row = new char[8];

// König (King)
var k = rnd.Next(1, 7);
row[k] = 'K';

// Turm (Rock) links 
row[rnd.Next(k)] = 'R';

// Turm (Rock) rechts 
row[rnd.Next(k + 1, 7)] = 'R';

// Läufer (Bishop) schwarzes Feld
var b1 = GetEmpties(row).Where(x => x % 2 == 0).ToList();
row[b1[rnd.Next(b1.Count)]] = 'B';

// Läufer (Bishop) weißes Feld
var b2 = GetEmpties(row).Where(x => x % 2 != 0).ToList();
row[b2[rnd.Next(b2.Count)]] = 'B';

// Dame (Queen)
var q = GetEmpties(row).ToList();
row[q[rnd.Next(q.Count)]] = 'Q';

// Springer (kNight) 1
var n1 = GetEmpties(row).ToList();
row[n1[rnd.Next(n1.Count)]] = 'N';

// Springer (kNight) 2
row[GetEmpties(row).ToList().FirstOrDefault()] = 'N';

// Ausgabe
Console.WriteLine(string.Join(" | ", row));
                

Lösung von: Jens Kelm (@JKooP)

// C++ 17 | VS-2022
// zufällige Ausgangsstellung
#include <iostream>
#include <vector>
#include <random>

enum fields {
	all, white, black
};

inline auto get_empties(const std::vector<char>& arr, const fields& field = fields::all) {
	std::vector<int>v{};
	for (auto i{ 0 }; i < arr.size(); ++i)
		if (arr[i] == '\0') {
			if (field == fields::black && i % 2 == 0) v.push_back(i);
			if (field == fields::white && i % 2 != 0) v.push_back(i);
			if (field == fields::all) v.push_back(i);
		}
	return v;
}

inline auto get_random(size_t first, size_t last) {
	std::random_device dev;
	const std::mt19937 rng(dev());
	std::uniform_int_distribution<size_t>dist(first, last);
	return dist(rng);
}

int main() {
	std::vector<char>row(8);

	// King
	const auto k{ get_random(1, 6) };
	row[k] = 'K';

	// Rock left
	row[get_random(0, k - 1)] = 'R';

	// Rock right
	row[get_random(k + 1, 7)] = 'R';

	// Bishop black field
	const auto bb{ get_empties(row, fields::black) };
	row[bb[get_random(0, bb.size() - 1)]] = 'B';

	// Bishop white field
	const auto bw{ get_empties(row, fields::white) };
	row[bw[get_random(0, bw.size() - 1)]] = 'B';

	// Queen
	const auto q{ get_empties(row) };
	row[q[get_random(0, q.size() - 1)]] = 'Q';

	// kNight 1
	const auto n1{ get_empties(row) };
	row[n1[get_random(0, n1.size() - 1)]] = 'N';

	// kNight 2
	const auto n2{ get_empties(row) };
	row[n2[0]] = 'N';

	for (const auto& r : row)
		std::cout << r << " ";
}
                

Lösung von: Jens Kelm (@JKooP)

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 2
Schwierigkeit: Mittel
Webcode: bqbb-3urx
Autor: ()

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen