Programmieren lernen

// 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)