Programmieren lernen

/**
 * Erzeuge ein Zufallspasswort nach folgender Vorgabe
 * Wort | Sonderzeichen | Zahl
 * 
 * * Jedes Wort hat 4 bis 6 Buchstaben
 *     Nur der erste Buchstabe darf groß sein
 *     Es wechselt ab zwischen Vokalen und Konsonanten
 * * Jede Zahl ist eine Zufallszahl von 2 bis 999
 * * Sonderzeichen sind vogegeben. Es kommt genau eines vor.
 * 
 * Achtung: Verwechselbare Buchstaben/Ziffern
 *          dürfen nicht vorkommen!
 * 
 * @author Philipp Gressly (phi AT gressly DOT ch)
 */
public interface Passwortgenerator {
  final String VOKALE_KLEIN       = "aeiouöäüy";
  final String VOKALE_GROSS       = "AEUÄÖÜY";
  final String KONSONANTEN_KLEIN  = "bcdfhjkmnprstvwxz";
  final String KONSONANTEN_GROSS  = "BCDFGHJKLMNPQRSTVWXZ";
  final String ZIFFER             = "23456789";
  final String SONDERZEICHEN      = "\\/%$#@!-_=+?,.<>(){}[]";
  
  /**
   * @param laenge 6 - 10 Zeichen.
   *        6: Vare-1
   *       10: Ralese#342 
   * @return
   */
  String passwort(int laenge); 

}  // end of class Passwortgenerator
//////////////////////////////////////////////////////////////////////////////
public class PasswortImplementation implements Passwortgenerator {

    /* overriden */
    @Override
    public String passwort(int laenge) {
        if(laenge < 6 || laenge > 10) {
            return "";
        }
        int wortLaenge = 4;
        int zahlLaenge = 1;
        if(laenge > 6) {
            wortLaenge++;
            if(laenge > 7) {
                zahlLaenge++;
                if(laenge > 8) {
                    wortLaenge++;
                    if(laenge > 9) {
                        zahlLaenge++;
                    }
                }
            }
        }
        return passwort(wortLaenge, zahlLaenge);
    }


    private String passwort(
            int wortLaenge,
            int zahlLaenge) {
        return randomWort(wortLaenge) +
               zufallAus(SONDERZEICHEN) + 
               randomZahl(zahlLaenge);
    }



    String randomZahl(int zahlLaenge) {
       String resultat = "";
       for(int i = 1; i <= zahlLaenge; i++) {
           resultat += zufallAus(ZIFFER);
       }
       return resultat;
    }


    private String randomWort(int wortLaenge) {
       String resultat = "";
       boolean konsonant = true; // letztes zeichen ist k.
       if(Math.random() < 0.5) { // konsonant
         if(Math.random() < 0.5) {
             resultat = zufallAus(KONSONANTEN_KLEIN);              
         } else {
             resultat = zufallAus(KONSONANTEN_GROSS);
         }
       } else {
           konsonant = false;
           if(Math.random() < 0.5) {
               resultat = zufallAus(VOKALE_KLEIN);
           } else {
              resultat  = zufallAus(VOKALE_GROSS);
           }
       }
       for(int i = 0; i < wortLaenge - 1; i++) {
           if(konsonant) {
               resultat = resultat + zufallAus(VOKALE_KLEIN);
           } else {
               resultat = resultat + zufallAus(KONSONANTEN_KLEIN);
           }
           konsonant ^= true;           
       }     
       return resultat;
    }


   String zufallAus(String moeglicheZeichen) {
       int len = moeglicheZeichen.length();
       int pos = zufallsPos(len);
       return "" + moeglicheZeichen.charAt(pos);
       
    }


   int zufallsPos(int length) {
        return (int) (Math.random() * length);
    }
   

} // end of class PasswortImplementation
////////////////////////////////////////////////////////////////////////////////
import java.util.Scanner;

public class TestPass {
  public static void main(String[] args) {
    new TestPass().top();   
  }
  
  Passwortgenerator pg = new PasswortImplementation();
  
  void top() {

      while(true) {
          String eingabe = eingabe("Anzahl 6-10 oder ENDE");
          if("ENDE".equals(eingabe)) {
              System.exit(0);
          }
          String passwort = pg.passwort(Integer.parseInt(eingabe));
          System.out.println("Ihr Passwort: " + passwort);
      }
  }

 Scanner sc = new Scanner(System.in);
 String eingabe(String frage) {
    System.out.println("Bitte " + frage + " eingeben: ");
    return sc.next();
  }
} // end of class TestPass
                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

/**
 * @author Nils Caspar (ThinkClever GmbH)
 */
class RandomPasswordGenerator {
    
    const VOCALS = 'aeiou';
    
    const VOCALS_UC = 'AEU';
    
    const CONSONANTS = 'bcdfghjkmnpqrstvw';
    
    const CONSONANTS_UC = 'BCDFGHJKMNPQRSTVW';
    
    const SPECIAL_CHARS = '!@#$%^&*().:?';
    
    public function getPassword($length) {
        if($length < 6 || $length > 10) {
            throw new InvalidArgumentException('$length muss zwischen 6 und 10 sein');
        }
        $lengthWord = 4;
        $lengthNumber = 1;
        for($i = 7; $i <= $length; ++$i) {
            if($i % 2) {
                ++$lengthWord;
            } else {
                ++$lengthNumber;
            }
        }
        return $this->_getRandomWord($lengthWord) . $this->_getRandomSpecialChar() . $this->_getRandomNumber($lengthNumber);
    }
    
    private function _getRandomNumber($lengthNumber) {
        $number = '';
        for($i = 0; $i < $lengthNumber; ++$i) {
            $number .= mt_rand(2, 9);
        }
        return $number;
    }
    
    private function _getRandomSpecialChar() {
        return $this->_getRandomChar(self::SPECIAL_CHARS);
    }
    
    private function _getRandomChar($string) {
        return $string[mt_rand(0, strlen($string) - 1)];
    }
    
    private function _getRandomWord($lengthWord) {
        $firstConsonant = mt_rand(0, 1);
        $word = $this->_getRandomChar($firstConsonant ? self::CONSONANTS_UC : self::VOCALS_UC);
        for($i = 1; $i < $lengthWord; ++$i) {
            $word .= $this->_getRandomChar($i % 2 != $firstConsonant ? self::CONSONANTS : self::VOCALS);
        }
        return $word;
    }
}

$pwGenerator = new RandomPasswordGenerator();
echo $pwGenerator->getPassword(6);
                

Lösung von: Nils Caspar (ThinkClever GmbH)

// Autor:				Andy Großhennig
// Solution for task:	Merkbares Zufallspasswort (Zeichenketten)

#include <iostream>
#include <string>
#include <time.h>
#include <Windows.h>

using namespace std;

// Function: First random! Provide a random number which manage the vowal - consonant rythm and the amount of letters and numbers
short getStringOption()
{
	Sleep(250);
	short number; //Output number
	srand(GetTickCount());
	number = rand() % 3; //Gives a number between zero and two

	return number;
}

// Function: Second random!  Provide a random number to manage which charakter shall add to the password
short getArrayNumber(short shChanceNumber)
{
	Sleep(250);
	short chance, standard = 3; //Output number, input number
	srand(GetTickCount());
	chance = rand() % shChanceNumber; //Gives a number between zero and the input number -1

	return chance;
}

// Function: Create Password
void generatePassword()
{
	char c_arrUpperLetter[19] = {'B', 'C', 'D', 'F', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'R', 'S', 'T', 'V', 'W', 'X', 'Y', 'Z'};
	char c_arrLowerLetter[19] = {'b', 'c', 'd', 'f', 'h', 'j', 'k', 'l', 'm', 'n', 'p', 'r', 's', 't', 'v', 'w', 'x', 'y', 'z'};
	char c_arrUpperVowal[4] = {'A', 'E', 'O', 'U'};
	char c_arrLowerVowal[4] = {'a', 'e', 'o', 'u'};
	char c_arrSpecial[30] = {'^', '!', '"', '$', '%', '&', '/', '(', ')', '=', '?', '*', '\'', '#', ',', '.', '-', '@', '~', '<', '>', '|', '{', '[', ']', '}', '\\', '+', '-', '*'};
	char c_arrNumbers[8] = {'2', '3', '4', '5', '6', '7', '8', '9'};
	short shStringOptionOut, shArrayNumberIn, shArrayNumberOut; //Output number for first random, input number for second random, output number for second random
	bool isLastVowal; //Manage the rythm between vowals and consonants
	string sPassword;
	
	shStringOptionOut = getStringOption(); //Number for: Begin with vowal or consonant
	
	if(shStringOptionOut == 0 || shStringOptionOut == 2)
	{
		shArrayNumberIn = 19; //If statement for upper letter (array length: 19)
		shArrayNumberOut = getArrayNumber(shArrayNumberIn); //Get a random number
		sPassword += c_arrUpperLetter[shArrayNumberOut]; //Add the letter in the random index to the password
		isLastVowal = false;
	}
	else if(shStringOptionOut == 1)
	{
		shArrayNumberIn = 4; //If statement for upper vowal (array length: 4)
		shArrayNumberOut = getArrayNumber(shArrayNumberIn);
		sPassword += c_arrUpperVowal[shArrayNumberOut];
		isLastVowal = true;
	}
	
	shStringOptionOut = getStringOption(); //Number for: Amount of letters

	for(short sh = -2;sh <= shStringOptionOut;sh++) //Amount of letters between four and six
	{
		if(isLastVowal == true)
		{
			shArrayNumberIn = 19;
			shArrayNumberOut = getArrayNumber(shArrayNumberIn);
			sPassword += c_arrLowerLetter[shArrayNumberOut];
			isLastVowal = false;
		}
		else
		{
			shArrayNumberIn = 4;
			shArrayNumberOut = getArrayNumber(shArrayNumberIn);
			sPassword += c_arrLowerVowal[shArrayNumberOut];
			isLastVowal = true;
		}
	}

	shArrayNumberOut = getArrayNumber(shArrayNumberIn);
	sPassword += c_arrSpecial[shArrayNumberOut]; //Add a random special sign

	shStringOptionOut = getStringOption(); //Number for: Amount of Numbers

	for(short sh = 0;sh <= shStringOptionOut;sh++) //Amount of Numbers between one and three
	{
		shArrayNumberIn = 8;
		shArrayNumberOut = getArrayNumber(shArrayNumberIn);
		sPassword += c_arrNumbers[shArrayNumberOut];
	}

	cout << sPassword;
}
int main()
{
	generatePassword();


	cout << "\n\n";
	system("Pause");
	return 0;
}
                

Lösung von: Andy Großhennig (Bundeswehr)

package test;

public class PWGenerator {

    static String[] vowels = { "a", "e", "i", "o", "u" };
    static String[] capitalVowels = { "A", "E", "O", "U" };
    static String[] consonants = { "b", "c", "d", "f", "h", "j", "k", "m", "n", "p", "r", "s", "t", "v", "w", "x", "z" };
    static String[] capitalConsonants = { "B", "C", "D", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S",
            "T", "V", "W", "X", "Z" };
    static String[] numbers = { "2", "3", "4", "5", "6", "7", "8", "9" };
    static String[] specialCharacters = { "\\", "/", "%", "$", "#", "@", "!", "-", "_", "=", "+", "?", ",", ".", "<",
            ">", "(", ")", "[", "]", "{", "}" };

    static String randomPassword = "";

    public static String addRandomElement(String[] array) {
        randomPassword += array[(int) ((double) Math.random() * array.length)];
        return randomPassword;
    }

    public static void generatePassword() {

        // 0.21053 = ~4/19, so the probability of every starting letter is equal
        // (4 capital vowels, 15 capital consonants)
        if (Math.random() < 0.21053) {
            addRandomElement(capitalVowels);
            addRandomElement(consonants);
            addRandomElement(vowels);
            addRandomElement(consonants);

            switch ((int) ((double) Math.random() * 3)) {
            case 0:
                break;
            case 1:
                addRandomElement(vowels);
                break;
            case 2:
                addRandomElement(vowels);
                addRandomElement(consonants);
                break;
            }

        } else {
            addRandomElement(capitalConsonants);
            addRandomElement(vowels);
            addRandomElement(consonants);
            addRandomElement(vowels);

            switch ((int) ((double) Math.random() * 3)) {
            case 0:
                break;
            case 1:
                addRandomElement(consonants);
                break;
            case 2:
                addRandomElement(consonants);
                addRandomElement(vowels);
                break;
            }
        }

        addRandomElement(specialCharacters);

        addRandomElement(numbers);

        switch ((int) ((double) Math.random() * 3)) {
        case 0:
            break;
        case 1:
            addRandomElement(numbers);
            break;
        case 2:
            addRandomElement(numbers);
            addRandomElement(numbers);
            break;
        }

    }

    public static void main(String[] args) {
        generatePassword();
        System.out.println(randomPassword);
    }
}
                

Lösung von: Ira Darkness ()

/*
    - Liste von Objekten (character)
    - Zeichen aus ASCII Tabelle
*/
#include <stdio.h>
#include <stdlib.h> //srand()
#include <conio.h>  //getch()
#include <time.h>   //time(0)

class Password
{
    private:

    char letter;
    Password *next;

    public:

    void create()
    {
		//Anfang der Liste initialisieren
        next = NULL;
        //Erstes Zeichen klein oder Großbuchstabe
        if(rand()%2 == 0)
            setLetter(rand()%(122-97+1)+97);
        else
            setLetter(rand()%(90-65+1)+65);

        //Das Wort fortführen
        int number = rand()%3+3; //Länge zufällig
        if(is_vocal())
        {
            for(int i = 0; i < number; i++)
            {
                if(i%2 == 0) //Im Wechsel Konsonante und Vokal
                {
                    put(getRandConsonant());
                }
                else
                {
                    put(getRandVocal());
                }
            }
        }
        else
        {
            for(int i = 0; i < number; i++)
            {
                if(i%2 != 0)
                {
                    put(getRandConsonant());
                }
                else
                {
                    put(getRandVocal());
                }
            }
        }

        //Sonderzeichen hinzufügen
        put(rand()%(64-58+1)+58);

        //Zahl hinzufügen
        number = rand()%3+1;
        for(int i = 0; i < number; i++)
            put(rand()%(57-50+1)+50);
    }

    void put(char c) //Neuen Character an die Liste anfügen
    {
        if(next == NULL)
        {
            Password *neu = (Password*) malloc (sizeof(Password));
            neu->letter = c;
            neu->next = next;
            next = neu;
        }
        else next->put(c);
    }

    void out() //Ausgabe der Liste
    {
        printf("%c", letter);
        if(next == NULL)printf("\n");
        else next->out();
    }

    void freemem() //Gibt den Speicherplatz der Liste frei
    {
        if(next != NULL)
        {
            next->freemem();
            free(next);
        }
    }

	//Getter und Setter
    char getLetter()
    {
        return letter;
    }

    void setLetter(char c)
    {
        letter = c;
    }

    bool is_vocal() //Prüft ob der gegenwärtige Buchstabe ein Vokal ist
    {
        if(letter == 65 || letter == 69 || letter == 73 || letter == 79 || letter == 85 || letter == 97 || letter == 101 || letter == 105 || letter == 111 || letter == 117)
            return true;
        else return false;
    }

    char getRandVocal() //nur Kleinbuchstaben
    {
        //kein o
        char temp;
        bool run = true;
        while(run)
        {
            temp = rand()%(122-97+1)+97;
            if(temp == 97 || temp == 101 || temp == 105 || temp == 117)run = false;
        }
        return temp;
    }

    char getRandConsonant() //nur Kleinbuchstaben
    {
        //kein l kein q, kein g
        char temp;
        bool run = true;
        while(run)
        {
            temp = rand()%(122-97+1)+97;
            if(!(temp == 97) && !(temp == 101) && !(temp == 105) && !(temp == 111) && !(temp == 117) && !(temp == 108) && !(temp == 113) && !(temp == 103))run = false;
        }
        return temp;
    }
};

int main()
{
    srand(time(0));
    Password pw;

    while(1)
    {
        printf("Liste von Passwoertern:\n\n");
        for(int i = 0; i < 10; i++)
        {
            pw.create();
            pw.out();
            pw.freemem();
            printf("\n");
        }
        printf("\nEscape beendet, andere Taste fuer weitere Passwoerter.");
        if(getch() == 27)break;
        system("CLS");
    }
    return 0;
}

                

Lösung von: Christian :) (Hochschule Merseburg)

import math
import random
import itertools
import string

VOWELS = list("aeiou")
CONSONANTS = list(set(string.ascii_lowercase)-set(VOWELS))
SPECIALSYMBOLS = list("!§$%&/=?+*#~")
CONFUSABLELETTERS = "1lgqO0"

def boolinput(prompt):
    while True:
        r = input(prompt+" [J/N]: ")
        if r == "J":
            return True
        elif r == "N":
            return False
        else:
            pass

def elements_of(list1, list2):
    '''Return all elements of self which are elements of l'''
    return [e for e in list1 if e in list2]

def random_word(length):
    numberofletters = math.ceil(length/2)
    vowels = [random.choice(VOWELS) for i in range(numberofletters)]
    consonants = [random.choice(CONSONANTS) for i in range(numberofletters)]
    letters = list(itertools.chain.from_iterable(zip(consonants, vowels)))
    return "".join(letters[:length])

def random_special_symbols(length):
    return "".join([random.choice(SPECIALSYMBOLS) for i in range(length)])

def random_int(length):
    if length == 0:
        return 0
    if length == 1:
        return random.choice([1,2,3,4,5,6,7,8,9])
    if length == 2:
        first = random.choice([1,2,3,4,5,6,7,8,9])
        second = (first+random.choice([1,-1])) % 10
        return int("".join([str(first), str(second)]))
    if length == 3:
        first, second = [d for d in str(random_int(2))]
        return int(first+second+first)
    else:
        #This repeats the digits of random_int(2)
        #length == 3: first+second+first
        #length == 4: first+second+first+second
        #length == 5: first+second+first+second+first
        #...
        numberofdigits = math.ceil(length/2)
        first, second = [d for d in str(random_int(2))]
        firsts = [first for i in range(numberofdigits)]
        seconds = [second for i in range(numberofdigits)]
        digits = list(itertools.chain.from_iterable(zip(firsts, seconds)))
        return int("".join(digits[:length-1]))

def get_string_without(letters, func):
    r = func()
    while elements_of(r, letters):
        r = func()
    return r
            
def get_password_():
    r = []
    r.append(random_word(random.randint(4, 6)).capitalize())
    r.append(random_special_symbols(1))
    r.append(str(random_int(random.randint(1, 3))))
    return "".join(r)

def get_password():
    #Password with the restrictions of the task
    return get_string_without(CONFUSABLELETTERS, get_password_)

def get_strong_password_():
    r = []
    rw = random_word(random.randint(5, 7))
    rw = rw[:2].upper()+rw[2:]
    r.append(rw)
    specialsymbol = random_special_symbols(1)
    r.append(specialsymbol)
    r.append(str(random_int(random.randint(2, 4))))
    r.append(specialsymbol)
    return "".join(r)

def get_strong_password():
    #Stronger passwords to get a valid password in the valid password task (xy54-zafk)
    return get_string_without(CONFUSABLELETTERS, get_strong_password_)

print("Dies ist ein Generator fuer merkbare Zufallspasswoerter.")
if boolinput("Brauchen Sie ein starkes Passwort?"):
    print("Das starke generierter Zufallspasswort ist:", get_strong_password())
else:
    print("Das generierte Zufallspasswort ist:", get_password())

                

Lösung von: Karl Welzel ()

function memorablePW() {
   var theString = "aeoubcdfhjkmnpqrstvwxyz", 
       pw = "",
       i = 1;
   
   function rnd(min, max) { 
      return (Math.floor(Math.random() * (max - min + 1)) + min);
   }
   
   // wort
   for (i; i < rnd(3, 4); i++) {
      pw += theString[rnd(4, theString.length-1)];
      pw += theString[rnd(0, 3)];
   }
   if (rnd(0, 1) == 1) pw = pw.substr(0, 5);
   pw = pw.substring(0, 1).toUpperCase() + pw.substring(1, pw.length);
   
   // sonderzeichen
   theString = "°!§$%&/()=?*+#_-@€";
   pw += theString[rnd(0, theString.length-1)];
   
   // zahl
   for (i = 1; i <= rnd(1, 3); i++) pw += rnd(2, 9);
   
   return pw;
}

console.log(memorablePW());
                

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

// NET Core 3.x; C# 8.x

using System;
using System.Collections.Generic;
using System.Linq;

namespace CS_Aufgabe_Zufallspasswort
{
    class Program
    {
        const string Ltr = @"aeubcdfhjkmnprstvwxyz";
        const string Chr = @"!-_=+?,.\\/%$#@<>(){}[]";

        static void Main(string[] args)
        {
            var p = string.Empty;
            var r = new Random();
            var l = new List<string>();

            for (int i = 0; i < 3; i++)
            {
                l.Add(GetChr(Ltr[3..].ToList()));
                l.Add(GetChr(Ltr[..3].ToList()));
            }

            l.RemoveRange(0, r.Next(0, 3));
            p = string.Join("", l);
            if (r.Next(0, 2) == 1) p = p[..1].ToUpper() + p[1..];
            p += GetChr(Chr.ToList());
            p += string.Join("", Enumerable.Range(1, r.Next(1, 4)).Select(x => r.Next(2, 10)));

            static string GetChr(List<char> lst) => lst.OrderBy(x => Guid.NewGuid()).FirstOrDefault().ToString();

            Console.WriteLine(p);
        }
    }
}
                

Lösung von: Jens Kelm (@JKooP)

// C++14 | VS-2022

#include <iostream>
#include <random>
#include <numeric>
#include <string>
#include <array>

int main() {

    /* Zufall initialiseren */
    srand(int(time(nullptr)));

    /* Variablen */
    std::string password, word, number;

    /* Array mit Zeichensätzen (R=Raw [Verbatim]) */
    const std::array<std::string, 4> chars{
        /* Vokale        */ "aeu",
        /* Konsonanten   */ "bcdfhjkmnprstvwxyz",
        /* Sonderzeichen */ R"(!-_=+?,.\/%$#@<>(){}[])",
        /* Ziffern       */ "23456789"};

    /* Lambda: Ermitteln eines Zufallszeichens */
    const auto get_char{ [&chars](const auto& x) {
        return chars[x][rand() % chars[x].length()]; } };

    /* ein Wort mit 6 Buchstaben abwechselnd Konsonant/Vokal
       (Beginn per Zufall [0:false..1:true]) */
    auto begin{ bool(rand() % 2) };
    for (auto i{ 0 }; i < 6; ++i) {
        word += get_char(begin);
        begin = !begin;
    }

    /* Wort auf 4 bis 6 Zeichen kürzen (Zufallszahl [4..6]) */
    word.resize(rand() % 3LL + 4);

    /* erster Buchstabe gross (Zufallszahl [0:nein..1:ja]) */
    if (rand() % 2) word[0] = std::toupper(word[0]);
    password += word;

    /* ein Sonderzeichen */
    password += get_char(2);

    /* eine Zahl (Länge durch Zufallszahl [1..3]) */
    for (auto i{ 0 }; i < (rand() % 3 + 1); ++i)
        number += get_char(3);
    password += number;

    /* Ausgabe */
    std::cout << password << "\n";
}
                

Lösung von: Jens Kelm (@JKooP)

// NET 7.x | C# 11.x | VS-2022

/* Zufall initialiseren */
var rnd = new Random();

/* Liste mit Zeichensätzen (@ = Verbatim) */
var chars = new List<string> { 
        /* Vokale        */ @"aeu",
        /* Konsonanten   */ @"bcdfhjkmnprstvwxyz",
        /* Sonderzeichen */ @"(!-_=+?,.\/%$#@<>(){}[])",
        /* Ziffern       */ @"23456789" };

/* Lambda: Ermitteln eines Zufallszeichens aus Zeichensätzen */
var chr = (int x) => chars[x].OrderBy(x => rnd.Next()).FirstOrDefault();

/* ein Wort mit 6 Buchstaben abwechselnd Konsonant/Vokal (Beginn per Zufall) */
var word = string.Empty;
var begin = rnd.Next(0, 2);
for (var i = 0; i < 6; i++) {
    word += chr(begin);
    begin = (begin == 1 ? 0 : 1);
}

/* Wort auf 4 bis 6 Zeichen kürzen (Zufallszahl [4..6]) */
word = word[..(rnd.Next(4,7))];

/* erster Buchstabe gross (Zufallszahl [0:nein..1:ja]) */
if (rnd.Next(0, 2) == 1) word = char.ToUpper(word[0]) + word[1..];
var password = word;

/* ein Sonderzeichen */
password += chr(2);

/* eine Zahl (Länge durch Zufallszahl [1..3]) */
var number = string.Empty;
for (var i = 0; i < rnd.Next(1, 4); i++)
    number += chr(3);
password += number;

/* Ausgabe */
Console.WriteLine(password);
                

Lösung von: Jens Kelm (@JKooP)