/// <summary>
/// Testar dina avancerade kunskaper.
/// </summary>
/// <param name="debugX">Vilken kolumn på consolen som texten ska läggas in i</param>
/// <returns>Procentvärde av resultat.</returns>
internal static double Avancerad(int debugX = 46)
{
const int max = 15;
var score = 0;
NiceDebug.Reset(debugX);
var check = new CSRepAvancerad();
score += VerifyInput(check.LessIsFirst(10, 2), 2, 10);
score += VerifyInput(check.LessIsFirst(4, 3), 3, 4);
score += VerifyInput(check.LessIsFirst(12, 22), 12, 22);
score += VerifyInput(check.Swap("AA", "BB"), "BB", "AA");
score += VerifyInput(check.Swap("Hej", "Ciao"), "Ciao", "Hej");
score += VerifyInput(check.Swap("Katt", "Hund"), "Hund", "Katt");
score += VerifyInput(check.LinQSum(2, 5, 23, 342, 12, 11, 24, 76), 495);
score += VerifyInput(check.LinQAvg(2, 5, 23, 342, 12, 11, 24, 76), 61.875);
score += VerifyInput(check.SortText("marcus"), "acmrsu");
score += VerifyInput(check.SortText("jultomten"), "ejlmnottu");
score += VerifyInput(check.FindWord(3, "Katt", "Hund", "Ros", "Röd ros", "Jultomte"), "Ros");
score += VerifyInput(check.FindWord(5, "Elefant", "Tidtabell", "Planering", "Musik", "Spotify"), "Musik");
score += VerifyInput(check.LinQHiscore(100, 32, 127, 95, 47, 89, 112), 127);
score += VerifyInput(check.LinQWorstPlayer(100, 32, 127, 95, 47, 89, 112), 32);
score += VerifyInput(check.IsLeet(100, 1773, 127, 95, 47, 89, 112), true);
return(Math.Round((double)score / max * 100));
}
/// <summary>
/// Testar dina ninjakunskaper.
/// </summary>
/// <param name="debugX">Debugtext position<see cref="int"/>.</param>
/// <returns>Procentvärde av resultat.</returns>
public static double Ninja(int debugX = 86)
{
Random rnd = new Random();
const int max = 8;
int score = 0;
NiceDebug.Reset(debugX);
score += Test("Doctor Who", rnd.Next(0, 29));
score += Test("Doctor Strange", rnd.Next(0, 29));
score += Test("Doctor Watson", rnd.Next(0, 29));
score += Test("ZipaDee DooDah", -rnd.Next(0, 29));
score += Test("Den spanska räven rev en annan räv", -rnd.Next(0, 29));
score += Test("The quick brown fox jumps over the lazy dog", rnd.Next(0, 29));
score += Test("Baskervilles hund", rnd.Next(0, 29));
StringBuilder evilCheck = new StringBuilder("Flygande bäckasiner söka hwila på mjuka tuvor");
for (int weird = 0; weird < evilCheck.Length; weird++)
{
evilCheck[weird] = rnd.Next(2) == 0 ?
evilCheck[weird].ToString().ToUpper()[0] :
evilCheck[weird].ToString().ToLower()[0];
}
score += Test(evilCheck.ToString(), rnd.Next(0, 29));
return(Math.Round((double)score / max * 100));
}
/// <summary>
/// Ordna talen i storleksordning, den minsta först
/// </summary>
/// <param name="num1">Första talet</param>
/// <param name="num2">Andra talet</param>
/// <returns>Ny sträng med bokstäverna blandade</returns>
public (int num1, int num2) LessIsFirst(int num1, int num2)
{
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis($"LessIsFirst : {num1} & {num2}");
return(num1, num2);
}
/// <summary>
/// Du får en serie med tal och du ska se om talserien är Leet (innehåller 1337)
/// använd gärna LinQ
/// </summary>
/// <param name="numbers">Talen som ska kollas</param>
/// <returns><see langword="true"/>om det är leet!</returns>
public bool IsLeet(params int[] numbers)
{
bool isLeet = false;
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis($"IsLeet : {isLeet}");
return(isLeet);
}
/// <summary>
/// Hitta ordet som har en angiven längd, använd gärna LinQ
/// </summary>
/// <param name="words">Texten som ska sorteras</param>
/// <param name="length">Längden på ordet vi söker</param>
/// <returns>Det utvalda ordet</returns>
public string FindWord(int length, params string[] words)
{
string magicWord = "";
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis($"FindWord : {magicWord}");
return(magicWord);
}
/// <summary>
/// En klassiker, den byt plats på två variabler
/// </summary>
/// <param name="textA">Text som ska byta plats</param>
/// <param name="textB">Text som ska byta plats</param>
/// <returns>Texter som bytt plats</returns>
public (string, string) Swap(string textA, string textB)
{
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis($"Swap : {textA} <-> {textB}");
return(textA, textB);
}
/// <summary>
/// Du kommer att få en array med strängar och en int med max
/// antal strängar du ska slå ihop
/// Om du har arrayen {"Hej","Hallå","Bye","Ciao"]
/// max 2 --> HejHallå
/// max 3 --> HejHallåGoodbye
/// OBS: Om du får ett max värde som är längre än arrayen får programmet
/// inte krascha!
/// max 500 -> HejHallåByeCiao
/// </summary>
/// <param name="max">Max antal värden i arrayen som ska behandlas</param>
/// <param name="input">En array med olika antal värden som ska bearbetas</param>
/// <returns>Summan av alla tal i strängen.</returns>
public string FörstaVärden(int max, params string[] input)
{
string retVal = "";
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis("Första : " + retVal);
return(retVal);
}
/// <summary>
/// Räkna ut summan av talen som skickas in, använd LinQ för detta
/// </summary>
/// <param name="numbers">Tal som skickas in</param>
/// <returns>Summan</returns>
public int LinQSum(params int[] numbers)
{
int sum = 0;
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis($"Summa : {sum}");
return(sum);
}
/// <summary>
/// Du kommer att få ett obestämt antal tal som funktionen ska
/// returnera medelvärde på
/// (Linq Average räknas som fusk).
/// </summary>
/// <param name="tal">Alla tal som ska behandlas.</param>
/// <returns>Medelvärdet av talen.</returns>
public int Medelvärde(params int[] tal)
{
int medelvärde = 0;
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis("Medelvärdet är : " + medelvärde);
return(medelvärde);
}
/// <summary>
/// Den här metoden krypterar en textsträng enligt Caesarchiffer,
/// enbart åäö, bokstäver, siffror, punkt, komma och mellanslag är godkända
/// för input, övrigt ska ignoreras
/// Nyckeln talar om hur många positioner en bokstav eller ett nummer ska flyttas
/// nyckel:3 --> a=c, b=d, c=e.
/// </summary>
/// <param name="code">Text som ska krypteras.</param>
/// <param name="key">Nyckel som ska användas till kryptering.</param>
/// <returns>Krypterad sträng.</returns>
public string Caesarchiffer(string code, int key)
{
string resultat = "";
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis("Caesar :" + resultat);
return(resultat);
}
/// <summary>
/// The AntalDagar.
/// </summary>
/// <param name="start">Startdatum<see cref="DateTime"/>.</param>
/// <param name="s**t">Slutdatum<see cref="DateTime"/>.</param>
/// <returns>Antal dagar - <see cref="int"/>.</returns>
public int AntalDagar(DateTime start, DateTime s**t)
{
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
int resultat = 0;
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis($"Antal dagar : {resultat}");
return(resultat);
}
/// <summary>
/// Du får en lista med poäng från olika spelare, välj det lägsta värdet, använd LinQ för detta
/// </summary>
/// <param name="numbers">Tal som skickas in</param>
/// <returns>Worst score!</returns>
public int LinQWorstPlayer(params int[] numbers)
{
int worst = 0;
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis($"Worst Score : {worst}");
return(worst);
}
/// <summary>
/// Skriv ordet baklänges
/// </summary>
/// <param name="ord">Ordet som ska vändas på</param>
/// <returns></returns>
public string VändPåOrdet(string ord)
{
string retVal = "";
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis($"Vänd Ordet : {retVal} ({ord})");
return(retVal);
}
/// <summary>
/// Den här metoden ska ta trå strängar och addera dem
/// varannan bokstav,
/// Exempel: Katt,Hund = KHautntd.
/// </summary>
/// <param name="first">Första ordet<see cref="string"/>.</param>
/// <param name="second">Andra ordet<see cref="string"/>.</param>
/// <returns>Ny sträng med bokstäverna blandade.</returns>
public string VarannanBokstav(string first, string second)
{
string resultat = "";
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis($"Bokstäver : {resultat}");
return(resultat);
}
/// <summary>
/// Du får ett värden till en loop, varje runda loopen kör ska du
/// lägga till tecknet i variabeln "symbol" till en sträng.
/// length talar om för dig hur lång loopen ska vara (0 till length)
/// skip talar om hur ofta du ska skippa att lägga till symbolen i strängen
/// (Om skip är två ska symbolen inte läggas till varannan varv i loopen)
/// (Om skip är fem ska symbolen inte läggas till femte varv i loopen)
/// </summary>
/// <param name="length">Längden på din loop</param>
/// <param name="skipEvery">Efter hur många steg ska den skippa</param>
/// <param name="symbol">Symbolen som ska läggas till i strängen</param>
/// <returns>Strängen som genererats</returns>
public string ForSkip(int length, int skipEvery, char symbol)
{
string retVal = string.Empty;
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis("ForSkip : " + retVal);
return(retVal);
}
/// <summary>
/// Skapa en loop som går igenom alla siffror i en sträng
/// och adderar dem, när den är klar ska den returnera
/// summan, exempelvis "552" ska ge svaret "12" alla andra
/// tecken ska ignoreras "54.3" ska bli 12.
/// </summary>
/// <param name="nummer">Sträng med nummeriska värden<see cref="string"/>.</param>
/// <returns>Summan av alla tal i strängen.</returns>
public int SummeraText(string nummer)
{
int summa = 0;
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis("Summa : " + summa);
return(summa);
}
/// <summary>
/// Du kommer att få en array med 3 rader och 3 tecken i var rad, och symbol för spelaren
/// Det är spelplanen för luffarshack. Du kommer även att på coordinater
/// för nästa drag som X gör.
/// Spelaren vinner om tre av samma symbol ligger i rad, vertikalt, horizontellt eller diagonalt
///
/// Planen kan se ut såhär
///
/// rows[0]="XOX
/// rows[1]=" OX"
/// rows[2]="X O"
///
/// Om X vinner ska metoden returnera "X wins"
/// Om O vinner ska metoden returnera "O wins"
/// Om positionen som önskas är redan upptagen ska metoden returnera "error"
/// Om avgjort ska metoden returnera "draw"
/// Om inte alla rutor är fyllda och ingen har vunnit ska metoden returnera en "next move"
///
/// </summary>
/// <param name="rows">rader med spelplan</param>
/// <param name="row"></param>
/// <param name="col"></param>
/// <param name="player">Spelarens symbol</param>
/// <returns></returns>
public string TicTacToe(string[] rows, int row, int col, char player)
{
var resultat = string.Empty;
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis($"TicTacToe : {resultat}");
return(resultat);
}
/// <summary>
/// Sortera bokstäverna i ett ord som skickas in, använd gärna LinQ
/// </summary>
/// <param name="text">Texten som ska sorteras</param>
/// <returns>Den sorteade texten</returns>
public string SortText(string text)
{
string sortedText = "";
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis($"SortText : {sortedText}");
return(sortedText);
}
/// <summary>
/// En lärare ska räkna ut statistik på sina elever och behöver en metod som
/// räknar antal G och VG som klassen fått
/// Varning: Läraren är slarvig och skriver betygen G,VG,VG,g,G,vG, Gv osv
/// Varning2: Läraren är en smula slarvig med bokstavsordning så VG kan mycket väl bli GV
/// eller vara V
/// </summary>
/// <param name="betyg">Betygen som ska kontrolleras</param>
/// <returns>Antal elever som fick G och antal som fick VG.</returns>
public (int, int) EleversBetyg(params string[] betyg)
{
int gBetyg = 0;
int vgBetyg = 0;
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis($"G & VG : {gBetyg} & {vgBetyg}");
return(gBetyg, vgBetyg);
}
/// <summary>
/// Räkna ut medelvärdet av talen som skickas in, använd LinQ för detta
/// </summary>
/// <param name="numbers">Tal som skickas in</param>
/// <returns>Summan</returns>
public double LinQAvg(params int[] numbers)
{
double avg = 0;
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis($"Average : {avg}");
return(avg);
}
/// <summary>
/// Den här metoden lägger till x antal månader till det datumet som skickats in
/// </summary>
/// <returns>Det nya datumet</returns>
public DateTime LäggTillMånad(DateTime date, int month)
{
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
var resultat = date.AddMonths(month);
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis($"Datum : {resultat}");
return(resultat);
}
/// <summary>
/// Du får en lista med poäng från olika spelare, välj det högsta värdet, använd LinQ för detta
/// </summary>
/// <param name="numbers">Tal som skickas in</param>
/// <returns>Hi score!</returns>
public int LinQHiscore(params int[] numbers)
{
int max = 0;
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis($"Highscore : {max}");
return(max);
}
/// <summary>
/// Den här metoden lägger till x antal månader till det datumet som skickats in.
/// </summary>
/// <param name="date">The date<see cref="DateTime"/>.</param>
/// <param name="month">The month<see cref="int"/>.</param>
/// <returns>Det nya datumet.</returns>
public DateTime LäggTillMånad(DateTime date, int month)
{
DateTime resultat = new DateTime();
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis($"Datum : {resultat}");
return(resultat);
}
/// <summary>
/// The AntalDagar.
/// </summary>
/// <param name="start">Startdatum<see cref="DateTime"/>.</param>
/// <param name="s**t">Slutdatum<see cref="DateTime"/>.</param>
/// <returns>Antal dagar - <see cref="int"/>.</returns>
public int AntalDagar(DateTime start, DateTime s**t)
{
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
var dagar = s**t - start;
var resultat = dagar.Days;
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis($"Antal dagar : {resultat}");
return(resultat);
}
/// <summary>
/// Du kommer att få ett obestämt antal tal som funktionen ska
/// returnera medelvärde på
/// (Linq Average räknas som fusk).
/// </summary>
/// <param name="tal">Alla tal som ska behandlas</param>
/// <returns>Medelvärdet av talen</returns>
public int Medelvärde(params int[] tal)
{
int summa = 0;
int res = 0;
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
for (int i = 0; i < tal.Length; i++)
{
summa += tal[i];
}
res = summa / tal.Length;
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis("Medelvärdet är : " + res);
return(res);
}
/// <summary>
/// Den här metoden krypterar en textsträng enligt Caesarchiffer,
/// enbart åäö, bokstäver, siffror, punkt, komma och mellanslag är godkända
/// för input, övrigt ska ignoreras
/// Nyckeln talar om hur många positioner en bokstav eller ett nummer ska flyttas
/// nyckel:3 --> a=c, b=d, c=e
/// </summary>
/// <param name="code">Text som ska krypteras</param>
/// <param name="key">Nyckel som ska användas till kryptering</param>
/// <returns>Krypterad sträng</returns>
public string Caesarchiffer(string code, int key)
{
string resultat = "";
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
var chars = new StringBuilder();
for (int i = 'a'; i <= 'z'; i++)
{
chars.Append((char)i);
}
chars.Append("åäö");
chars.Append(chars.ToString().ToUpper());
chars.Append("0123456789 .,");
string allChars = chars.ToString();
for (int i = 0; i < code.Length; i++)
{
var symbol = code[i];
var pos = allChars.IndexOf(symbol);
if (pos >= 0)
{
pos += key;
if (pos >= allChars.Length)
{
pos -= allChars.Length;
}
if (pos < 0)
{
pos += allChars.Length;
}
resultat += (char)allChars[pos];
}
}
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis("Caesar :" + resultat);
return(resultat);
}
/// <summary>
/// Skapa en loop som går igenom alla siffror i en sträng
/// och adderar dem, när den är klar ska den returnera
/// summan, exempelvis "552" ska ge svaret "12" alla andra
/// tecken ska ignoreras "54.3" ska bli 12.
/// </summary>
/// <param name="nummer">Sträng med nummeriska värden<see cref="string"/>.</param>
/// <returns>Summan av alla tal i strängen.</returns>
public int SummeraText(string nummer)
{
int summa = 0;
// ---------------------------------------------------------------------------------
// Skriv din kod nedan
// ---------------------------------------------------------------------------------
for (int i = 0; i < nummer.Length; i++)
{
string ch = nummer.Substring(i, 1);
if (int.TryParse(ch, out int n))
{
summa += n;
}
}
// ---------------------------------------------------------------------------------
NiceDebug.DebugThis("Summa : " + summa);
return(summa);
}
/// <summary>
/// Testar dina ninjakunskaper.
/// </summary>
/// <returns>Procentvärde av resultat.</returns>
public static double Ninja(int debugX = 86)
{
var rnd = new Random();
const int max = 8;
int score = 0;
NiceDebug.Reset(debugX);
NiceDebug.MaxLength -= 4;
var check = new CSRepvNinja();
score += VerifyInput(check.TicTacToe(new string[] { "XOX", "O X", "OXO" }, 1, 1, 'X').ToLower(), "draw");
score += VerifyInput(check.TicTacToe(new string[] { "XOX", "O X", "OXX" }, 1, 1, 'X').ToLower(), "x wins");
score += VerifyInput(check.TicTacToe(new string[] { "X X", "OOX", "OXX" }, 1, 1, 'X').ToLower(), "error");
score += VerifyInput(check.TicTacToe(new string[] { "X X", "OOX", "OXO" }, 0, 1, 'O').ToLower(), "draw");
score += VerifyInput(check.TicTacToe(new string[] { "X X", " ", "OXO" }, 0, 1, 'O').ToLower(), "next move");
score += VerifyInput(check.TicTacToe(new string[] { "XOX", "OXO", " " }, 2, 1, 'O').ToLower(), "next move");
score += VerifyInput(check.TicTacToe(new string[] { "OOX", "OXO", "O X" }, 2, 1, 'X').ToLower(), "o wins");
score += VerifyInput(check.TicTacToe(new string[] { "XOX", "OXO", "O O" }, 2, 1, 'X').ToLower(), "draw");
return(Math.Round((double)score / max * 100));
}
/// <summary>
/// Testar dina grundkunskaper.
/// </summary>
/// <param name="debugX">Debugtext position<see cref="int"/>.</param>
/// <returns>Procentvärde av resultat.</returns>
public static double Grund(int debugX = 7)
{
const int max = 10;
int score = 0;
CSRepGrund check = new CSRepGrund();
NiceDebug.Reset(debugX);
score += VerifyInput(check.SummeraText("112"), 4);
score += VerifyInput(check.SummeraText("2+4=4"), 10);
score += VerifyInput(check.SummeraText("*****@*****.**"), 21);
score += VerifyInput(check.SummeraText("54.3"), 12);
score += VerifyInput(check.Medelvärde(1, 4, 8, 12, 43, 12), 13);
score += VerifyInput(check.Medelvärde(22, 32, 45, 67, 89, 11), 44);
score += VerifyInput(check.Medelvärde(99, 44, 33, 22, 10), 41);
score += VerifyInput(check.Medelvärde(10, 20), 15);
score += VerifyInput(check.MinimiOchMaximiVärde(25, 234, 11, 4, 22), (4, 234));
score += VerifyInput(check.MinimiOchMaximiVärde(-4, -22, -11, 0, 3), (-22, 3));
return(Math.Round((double)score / max * 100));
}
/// <summary>
/// Testar dina grundkunskaper.
/// </summary>
/// <returns>Procentvärde av resultat.</returns>
public static double Grund(int debugX = 7)
{
const int max = 9;
int score = 0;
var check = new CSRepvGrund();
NiceDebug.Reset(debugX);
score += VerifyInput(check.FörstaVärden(3, "A", "B", "C", "D", "Katt", "Hund"), "ABC");
score += VerifyInput(check.FörstaVärden(9, "R", "A", "M", "M", "S", "T", "E", "I", "N", "Du Hast"), "RAMMSTEIN");
score += VerifyInput(check.ForSkip(10, 3, '*'), new string('*', 6));
score += VerifyInput(check.ForSkip(32, 7, '*'), new string('*', 27));
score += VerifyInput(check.EleversBetyg("g", "G", "VG", "vg", "GV", "v", "V"), (2, 5));
score += VerifyInput(check.EleversBetyg("vg", "vG", "G", "g", "V", "G", "v", "V", "VG", "KATT"), (3, 6));
score += VerifyInput(check.VändPåOrdet("julafton"), "notfaluj");
score += VerifyInput(check.VändPåOrdet("aluminium"), "muinimula");
score += VerifyInput(check.VändPåOrdet("tacocat"), "tacocat");
return(Math.Round((double)score / max * 100));
}
