Första uppladdningen av övningsexempel
This commit is contained in:
commit
eb307ea123
88 files changed
+1293
No files matched your search
@@ -0,0 +1,8 @@
|
||||
// Vad innebär programmering, och varför måste instruktionerna
|
||||
// till en dator vara exakta och entydiga?
|
||||
|
||||
Programmering innebär att skriva instruktioner som talar om för
|
||||
en dator vad den ska göra. Instruktionerna måste vara exakta och
|
||||
entydiga eftersom datorn följer dem bokstavligt.
|
||||
Datorn kan inte själv tolka vad programmeraren egentligen menade
|
||||
om instruktionerna är felaktiga eller otydliga.
|
||||
@@ -0,0 +1,9 @@
|
||||
// Vad är skillnaden mellan datatyperna int, double, string och bool?
|
||||
// Ge ett exempel på ett värde som passar till varje datatyp.
|
||||
|
||||
De används för olika typer av data:
|
||||
|
||||
int används för heltal, till exempel 42.
|
||||
double används för decimaltal, till exempel 3.14.
|
||||
string används för text, till exempel "Christian".
|
||||
bool används för sant eller falskt, alltså true eller false.
|
||||
@@ -0,0 +1,8 @@
|
||||
// Skriv ett enkelt C#-program som frågar användaren efter
|
||||
// hens namn och sedan skriver ut en personlig hälsning,
|
||||
// till exempel ”Hej Christian!”.
|
||||
|
||||
Om användaren skriver Christian blir resultatet:
|
||||
|
||||
Vad heter du? Christian
|
||||
Hej Christian!
|
||||
@@ -0,0 +1,13 @@
|
||||
// Förklara vad som händer från det att du trycker på Run i Rider
|
||||
// tills programmets resultat visas. Ta med begreppet kompilering
|
||||
// i din förklaring.
|
||||
|
||||
När man trycker Run kontrolleras och kompileras C#-koden.
|
||||
Kompilering innebär att källkoden omvandlas till en form som .NET kan köra.
|
||||
|
||||
Om det finns kompileringsfel, exempelvis felaktig C#-syntax,
|
||||
kan programmet normalt inte startas.
|
||||
|
||||
Om kompileringen lyckas startas programmet och instruktionerna körs.
|
||||
När programmet exempelvis använder Console.WriteLine() visas
|
||||
resultatet i konsolfönstret i Rider.
|
||||
@@ -0,0 +1,22 @@
|
||||
/*
|
||||
Studera följande programkod:
|
||||
|
||||
Console.Write("Namn: ");
|
||||
string namn = Console.ReadLine();
|
||||
Console.WriteLine($"Hej {namn}!");
|
||||
|
||||
Beskriv steg för steg vad varje del gör och i vilken ordning
|
||||
instruktionerna körs.
|
||||
*/
|
||||
|
||||
Console.Write("Namn: ");
|
||||
- Skriver ut texten Namn: i konsolen.
|
||||
|
||||
Console.ReadLine();
|
||||
- Programmet väntar på att användaren skriver något och trycker Enter.
|
||||
|
||||
string namn = ...
|
||||
- Texten användaren skrev sparas i variabeln namn.
|
||||
|
||||
Console.WriteLine($"Hej {namn}!");
|
||||
- Skriver ut en hälsning där värdet i variabeln sätts in i texten.
|
||||
@@ -0,0 +1,18 @@
|
||||
// Vad är en variabel, och varför används variabler i programmering?
|
||||
// Ge ett exempel på en variabel med ett beskrivande namn.
|
||||
|
||||
En variabel är ett namngivet ställe där programmet kan lagra ett
|
||||
värde som det kan använda senare.
|
||||
|
||||
Exempel:
|
||||
|
||||
int antalPoang = 100;
|
||||
|
||||
Här är:
|
||||
|
||||
int datatypen
|
||||
antalPoang variabelns namn
|
||||
100 värdet
|
||||
|
||||
Beskrivande variabelnamn gör dessutom programmet lättare
|
||||
att läsa och förstå.
|
||||
@@ -0,0 +1,16 @@
|
||||
// Vad är en IDE, och på vilka sätt kan Rider hjälpa dig när du
|
||||
// skriver och felsöker ett C#-program?
|
||||
|
||||
IDE står för Integrated Development Environment och är ett program
|
||||
som samlar verktyg för programmering på ett ställe.
|
||||
|
||||
Rider är en IDE som bland annat kan hjälpa till med att:
|
||||
|
||||
skriva och organisera C#-kod
|
||||
markera fel i koden
|
||||
föreslå och komplettera kod
|
||||
kompilera och köra program
|
||||
visa programmets utskrifter
|
||||
felsöka program med en debugger
|
||||
|
||||
Man behöver alltså inte själv använda separata program för varje steg.
|
||||
@@ -0,0 +1,19 @@
|
||||
// Vad innebär debugging? Förklara hur det kan hjälpa dig att hitta
|
||||
// fel genom att pausa programmet och följa körningen steg för steg.
|
||||
|
||||
Debugging innebär att felsöka ett program för att förstå varför det
|
||||
inte fungerar som tänkt.
|
||||
|
||||
I Rider kan man sätta en breakpoint på en viss rad. När programmet
|
||||
når den raden pausas körningen.
|
||||
|
||||
Därefter kan man till exempel:
|
||||
|
||||
- kontrollera vilka värden variablerna innehåller
|
||||
- köra en instruktion i taget
|
||||
- följa hur variabler förändras
|
||||
- se vilken väg programmet tar genom koden
|
||||
|
||||
Om ett program till exempel räknar ut fel resultat kan man pausa
|
||||
programmet och följa beräkningen steg för steg för att hitta raden
|
||||
där något börjar bli fel.
|
||||
@@ -0,0 +1,5 @@
|
||||
// Vad är en bit och vad är en byte? Hur många bitar består en byte av?
|
||||
|
||||
// En bit är den minsta informationsenheten i en dator och kan ha värdet 0 eller 1.
|
||||
// En byte är en grupp med 8 bitar.
|
||||
// En byte består alltså av 8 bitar.
|
||||
@@ -0,0 +1,8 @@
|
||||
// Omvandla det binära talet 0001 0011 till decimalform.
|
||||
|
||||
// Det binära talet 0001 0011 motsvarar:
|
||||
// 16 + 2 + 1 = 19
|
||||
// Talet är alltså 19 i decimalform.
|
||||
|
||||
int tal = 0b0001_0011;
|
||||
Console.WriteLine(tal);
|
||||
@@ -0,0 +1,8 @@
|
||||
// Vad betyder det att ett tal är hexadecimalt?
|
||||
|
||||
// Ett hexadecimalt tal använder talsystemet med basen 16.
|
||||
// Det använder siffrorna 0 till 9 och bokstäverna A till F.
|
||||
// A motsvarar 10, B motsvarar 11 och så vidare upp till F som motsvarar 15.
|
||||
|
||||
int tal = 0x13;
|
||||
Console.WriteLine(tal); // 19 i decimalform
|
||||
@@ -0,0 +1,13 @@
|
||||
// Vilken C#-datatyp skulle du välja för vart och ett av följande värden: ett antal böcker, ett pris, en bokstav, en hel mening och ett svar som är sant eller falskt?
|
||||
|
||||
int antalBocker = 12;
|
||||
decimal pris = 199.90m;
|
||||
char bokstav = 'A';
|
||||
string mening = "Det här är en hel mening.";
|
||||
bool arTillganglig = true;
|
||||
|
||||
Console.WriteLine(antalBocker);
|
||||
Console.WriteLine(pris);
|
||||
Console.WriteLine(bokstav);
|
||||
Console.WriteLine(mening);
|
||||
Console.WriteLine(arTillganglig);
|
||||
@@ -0,0 +1,11 @@
|
||||
// C# är statiskt typat. Vad innebär det? Varför fungerar det inte att tilldela texten "hej" till en variabel av typen int?
|
||||
|
||||
// Statiskt typat innebär att varje variabel har en bestämd datatyp.
|
||||
// Kompilatorn kontrollerar att variabeln bara får värden som passar datatypen.
|
||||
// En variabel av typen int kan lagra heltal, men texten "hej" är en string.
|
||||
// Därför kan texten inte tilldelas en int-variabel.
|
||||
|
||||
int tal = 10;
|
||||
string text = "hej";
|
||||
|
||||
// tal = "hej"; // Fungerar inte eftersom "hej" inte är ett heltal.
|
||||
@@ -0,0 +1,7 @@
|
||||
// Skriv ett C#-program som ber användaren skriva in ett heltal, omvandlar inmatningen till typen int och skriver ut talet plus 5. Du kan utgå från att användaren skriver in ett giltigt heltal.
|
||||
|
||||
Console.Write("Skriv ett heltal: ");
|
||||
string inmatning = Console.ReadLine();
|
||||
|
||||
int tal = int.Parse(inmatning);
|
||||
Console.WriteLine(tal + 5);
|
||||
@@ -0,0 +1,9 @@
|
||||
// Vad skrivs ut av respektive kodrad? Förklara skillnaden mellan att addera två heltal och att addera två strängar. Console.WriteLine(1 + 2); Console.WriteLine("1" + "2");
|
||||
|
||||
// Den första raden adderar heltalen 1 och 2 och skriver därför ut 3.
|
||||
// Den andra raden sammanfogar strängarna "1" och "2" och skriver därför ut 12.
|
||||
// När operatorn + används med tal utförs addition.
|
||||
// När operatorn + används med strängar utförs strängkonkatenering.
|
||||
|
||||
Console.WriteLine(1 + 2);
|
||||
Console.WriteLine("1" + "2");
|
||||
@@ -0,0 +1,13 @@
|
||||
// Förklara vad en variabel är. Vilka fyra egenskaper har en variabel enligt föreläsningen?
|
||||
|
||||
// En variabel är en namngiven plats i datorns minne där ett värde kan lagras.
|
||||
// Värdet kan läsas och ändras medan programmet körs.
|
||||
//
|
||||
// En variabel har fyra egenskaper:
|
||||
// 1. Namn, till exempel alder.
|
||||
// 2. Datatyp, till exempel int.
|
||||
// 3. Värde, till exempel 25.
|
||||
// 4. Scope, alltså var i programmet variabeln kan användas.
|
||||
|
||||
int alder = 25;
|
||||
Console.WriteLine(alder);
|
||||
@@ -0,0 +1,13 @@
|
||||
// Vad är skillnaden mellan en variabel och en konstant? Ge även exempel på när det kan vara lämpligt att använda en konstant.
|
||||
|
||||
// En variabel innehåller ett värde som kan ändras medan programmet körs.
|
||||
// En konstant innehåller ett värde som inte får ändras efter att det har skapats.
|
||||
// En konstant passar för värden som alltid ska vara desamma, till exempel antalet månader på ett år.
|
||||
|
||||
int antalPoang = 10;
|
||||
antalPoang = 20;
|
||||
|
||||
const int ManaderPerAr = 12;
|
||||
|
||||
Console.WriteLine(antalPoang);
|
||||
Console.WriteLine(ManaderPerAr);
|
||||
@@ -0,0 +1,11 @@
|
||||
// Skriv ett C#-program som frågar användaren efter ett heltal. Programmet ska med hjälp av en if/else-sats skriva ut om talet är positivt, negativt eller noll.
|
||||
|
||||
Console.Write("Ange ett heltal: ");
|
||||
int tal = int.Parse(Console.ReadLine());
|
||||
|
||||
if (tal > 0)
|
||||
Console.WriteLine("Talet är positivt");
|
||||
else if (tal < 0)
|
||||
Console.WriteLine("Talet är negativt");
|
||||
else
|
||||
Console.WriteLine("Talet är noll");
|
||||
@@ -0,0 +1,9 @@
|
||||
// Förklara skillnaden mellan = och == i C#. Beskriv vad de båda operatorerna används till.
|
||||
|
||||
// = är tilldelningsoperatorn. Den används för att ge en variabel ett värde.
|
||||
// == är jämförelseoperatorn. Den används för att kontrollera om två värden är lika.
|
||||
|
||||
int tal = 10;
|
||||
|
||||
if (tal == 10)
|
||||
Console.WriteLine("Talet är 10");
|
||||
@@ -0,0 +1,20 @@
|
||||
// Skriv ett C#-program som ber användaren att ange ett tal mellan 1 och 3. Använd en switch-sats för att skriva ut ”Ett”, ”Två” eller ”Tre”. Om användaren skriver något annat ska programmet skriva ut ”Ogiltigt tal”.
|
||||
|
||||
Console.Write("Ange ett tal mellan 1 och 3: ");
|
||||
int tal = int.Parse(Console.ReadLine());
|
||||
|
||||
switch (tal)
|
||||
{
|
||||
case 1:
|
||||
Console.WriteLine("Ett");
|
||||
break;
|
||||
case 2:
|
||||
Console.WriteLine("Två");
|
||||
break;
|
||||
case 3:
|
||||
Console.WriteLine("Tre");
|
||||
break;
|
||||
default:
|
||||
Console.WriteLine("Ogiltigt tal");
|
||||
break;
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
// Vad innebär scope i C#? Förklara varför en variabel som deklareras inuti ett kodblock inte kan användas utanför kodblocket.
|
||||
|
||||
// Scope beskriver i vilken del av programmet en variabel är tillgänglig.
|
||||
// En variabel som deklareras inuti ett kodblock kan bara användas i det blocket.
|
||||
// När kodblocket avslutas finns variabeln inte längre tillgänglig.
|
||||
|
||||
if (true)
|
||||
{
|
||||
int tal = 10;
|
||||
Console.WriteLine(tal);
|
||||
}
|
||||
|
||||
// Följande rad fungerar inte eftersom tal ligger utanför sitt scope:
|
||||
// Console.WriteLine(tal);
|
||||
@@ -0,0 +1,18 @@
|
||||
// Förklara skillnaden mellan de logiska operatorerna &&, || och !. Ge ett enkelt exempel på ett villkor där varje operator kan användas.
|
||||
|
||||
// && betyder OCH. Båda villkoren måste vara sanna.
|
||||
// || betyder ELLER. Minst ett av villkoren måste vara sant.
|
||||
// ! betyder INTE. Operatorn vänder på ett booleskt värde.
|
||||
|
||||
int alder = 20;
|
||||
bool harBiljett = true;
|
||||
bool arFullbokad = false;
|
||||
|
||||
if (alder >= 18 && harBiljett)
|
||||
Console.WriteLine("Du får komma in");
|
||||
|
||||
if (alder < 18 || !harBiljett)
|
||||
Console.WriteLine("Du får inte komma in");
|
||||
|
||||
if (!arFullbokad)
|
||||
Console.WriteLine("Det finns lediga platser");
|
||||
@@ -0,0 +1,16 @@
|
||||
// Vad är skillnaden mellan a++ och ++a? Förklara vad som händer när operatorn står efter respektive före variabeln.
|
||||
|
||||
// a++ ökar a med 1 efter att det gamla värdet har använts.
|
||||
// ++a ökar a med 1 innan det nya värdet används.
|
||||
|
||||
int a = 5;
|
||||
int b = a++;
|
||||
|
||||
Console.WriteLine(a); // 6
|
||||
Console.WriteLine(b); // 5
|
||||
|
||||
a = 5;
|
||||
int c = ++a;
|
||||
|
||||
Console.WriteLine(a); // 6
|
||||
Console.WriteLine(c); // 6
|
||||
@@ -0,0 +1,16 @@
|
||||
// Vad används en loop till? Beskriv kort skillnaden mellan while, do-while och for.
|
||||
|
||||
// En loop används för att upprepa kod flera gånger.
|
||||
//
|
||||
// while kontrollerar villkoret innan kodblocket körs. Därför kan koden köras noll gånger.
|
||||
// do-while kör kodblocket först och kontrollerar villkoret efteråt. Därför körs koden minst en gång.
|
||||
// for används ofta när man vet hur många gånger något ska upprepas. Startvärde,
|
||||
// villkor och förändring skrivs på samma rad.
|
||||
|
||||
int tal = 1;
|
||||
|
||||
while (tal <= 3)
|
||||
{
|
||||
Console.WriteLine(tal);
|
||||
tal++;
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
// Skriv en while-loop som skriver ut talen från 10 ned till 1.
|
||||
|
||||
int tal = 10;
|
||||
|
||||
while (tal >= 1)
|
||||
{
|
||||
Console.WriteLine(tal);
|
||||
tal--;
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
// Vad är en oändlig loop? Ge ett exempel på ett vanligt misstag som kan göra att en loop aldrig tar slut.
|
||||
|
||||
// En oändlig loop är en loop vars villkor aldrig blir falskt.
|
||||
// Ett vanligt misstag är att glömma att ändra variabeln som används i villkoret.
|
||||
|
||||
int tal = 1;
|
||||
|
||||
while (tal <= 10)
|
||||
{
|
||||
Console.WriteLine(tal);
|
||||
|
||||
// tal++ saknas. Därför förblir tal 1 och loopen tar aldrig slut.
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
// Förklara vad break respektive continue gör i en loop.
|
||||
|
||||
// break avslutar loopen direkt.
|
||||
// continue avbryter den aktuella iterationen och fortsätter med nästa.
|
||||
|
||||
for (int tal = 1; tal <= 10; tal++)
|
||||
{
|
||||
if (tal == 3)
|
||||
continue;
|
||||
|
||||
if (tal == 8)
|
||||
break;
|
||||
|
||||
Console.WriteLine(tal);
|
||||
}
|
||||
|
||||
// Talet 3 skrivs inte ut eftersom continue går vidare till nästa iteration.
|
||||
// När tal blir 8 avslutas loopen på grund av break.
|
||||
@@ -0,0 +1,14 @@
|
||||
// Vad är en array, och hur skiljer den sig från att lagra varje värde i en separat variabel? Förklara också vad ett index är och var indexeringen börjar.
|
||||
|
||||
// En array kan lagra flera värden av samma datatyp under ett gemensamt namn.
|
||||
// Det är smidigare än att skapa en separat variabel för varje värde, särskilt när
|
||||
// värdena ska behandlas på samma sätt eller gås igenom med en loop.
|
||||
//
|
||||
// Varje plats i arrayen har ett index. Indexet visar värdets position i arrayen.
|
||||
// Indexeringen börjar på 0, så det första värdet har index 0.
|
||||
|
||||
int[] tal = { 10, 20, 30 };
|
||||
|
||||
Console.WriteLine(tal[0]); // 10
|
||||
Console.WriteLine(tal[1]); // 20
|
||||
Console.WriteLine(tal[2]); // 30
|
||||
@@ -0,0 +1,8 @@
|
||||
// Skapa en array med fem heltal och skriv en loop som skriver ut alla värden i arrayen. Använd Length för att avgöra när loopen ska avslutas.
|
||||
|
||||
int[] tal = { 5, 10, 15, 20, 25 };
|
||||
|
||||
for (int i = 0; i < tal.Length; i++)
|
||||
{
|
||||
Console.WriteLine(tal[i]);
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
// Vad är skillnaden mellan en for-loop och en foreach-loop när du går igenom en array?
|
||||
|
||||
// En for-loop använder en räknare och ger tillgång till varje värdes index.
|
||||
// Den passar när man behöver veta eller använda positionen i arrayen.
|
||||
//
|
||||
// En foreach-loop går direkt igenom värdena utan att man behöver hantera ett index.
|
||||
// Den passar när man bara behöver läsa och använda varje värde.
|
||||
|
||||
string[] namn = { "Anna", "Bo", "Cecilia" };
|
||||
|
||||
for (int i = 0; i < namn.Length; i++)
|
||||
{
|
||||
Console.WriteLine($"Index {i}: {namn[i]}");
|
||||
}
|
||||
|
||||
foreach (string person in namn)
|
||||
{
|
||||
Console.WriteLine(person);
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
// Skapa en array med titlar på 8 st filmer. Använd en foreach-loop för att skriva ut alla titlarna.
|
||||
|
||||
string[] filmer =
|
||||
{
|
||||
"The Matrix",
|
||||
"Jurassic Park",
|
||||
"Interstellar",
|
||||
"Gladiator",
|
||||
"Alien",
|
||||
"Inception",
|
||||
"Titanic",
|
||||
"The Terminator"
|
||||
};
|
||||
|
||||
foreach (string film in filmer)
|
||||
{
|
||||
Console.WriteLine(film);
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
// Vad är en tvådimensionell array? Ge ett exempel på hur den kan användas och förklara varför man kan behöva nästlade loopar för att gå igenom alla dess värden.
|
||||
|
||||
// En tvådimensionell array lagrar värden i rader och kolumner, ungefär som en tabell.
|
||||
// Den kan exempelvis användas för sittplatser i en biosalong eller spelrutor på ett bräde.
|
||||
//
|
||||
// Nästlade loopar behövs eftersom en loop går igenom raderna och den andra går
|
||||
// igenom kolumnerna i varje rad.
|
||||
|
||||
int[,] spelplan =
|
||||
{
|
||||
{ 1, 2, 3 },
|
||||
{ 4, 5, 6 },
|
||||
{ 7, 8, 9 }
|
||||
};
|
||||
|
||||
for (int rad = 0; rad < spelplan.GetLength(0); rad++)
|
||||
{
|
||||
for (int kolumn = 0; kolumn < spelplan.GetLength(1); kolumn++)
|
||||
{
|
||||
Console.Write(spelplan[rad, kolumn] + " ");
|
||||
}
|
||||
|
||||
Console.WriteLine();
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
// Vad är den viktigaste skillnaden mellan en List och en array i C#? Ge ett exempel på när en List kan vara ett bättre val.
|
||||
|
||||
// En array har en bestämd storlek som inte kan ändras efter att arrayen har skapats.
|
||||
// En List kan däremot växa och minska medan programmet körs.
|
||||
//
|
||||
// En List är ett bättre val när man inte vet i förväg hur många värden som ska lagras.
|
||||
// Det kan till exempel vara en lista med namn som användaren själv fyller på.
|
||||
|
||||
List<string> namn = new List<string>();
|
||||
|
||||
namn.Add("Anna");
|
||||
namn.Add("Bo");
|
||||
namn.Add("Cecilia");
|
||||
|
||||
foreach (string person in namn)
|
||||
{
|
||||
Console.WriteLine(person);
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
// Förklara skillnaden mellan metoderna Add, Remove och RemoveAt när du arbetar med en lista.
|
||||
|
||||
// Add lägger till ett nytt värde sist i listan.
|
||||
// Remove tar bort det första värdet som stämmer överens med det angivna värdet.
|
||||
// RemoveAt tar bort värdet på ett visst index.
|
||||
|
||||
List<string> frukter = new List<string>
|
||||
{
|
||||
"Äpple",
|
||||
"Banan",
|
||||
"Citron"
|
||||
};
|
||||
|
||||
frukter.Add("Apelsin");
|
||||
frukter.Remove("Banan");
|
||||
frukter.RemoveAt(0);
|
||||
|
||||
foreach (string frukt in frukter)
|
||||
{
|
||||
Console.WriteLine(frukt);
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
// Skriv ett C#-program som skapar en lista med fem namn och sedan skriver ut alla namn med hjälp av en foreach-loop.
|
||||
|
||||
List<string> namn = new List<string>
|
||||
{
|
||||
"Anna",
|
||||
"Bo",
|
||||
"Cecilia",
|
||||
"David",
|
||||
"Erik"
|
||||
};
|
||||
|
||||
foreach (string person in namn)
|
||||
{
|
||||
Console.WriteLine(person);
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
// Vad används Count, Sort och Contains till när man arbetar med listor? Beskriv vad varje metod eller egenskap gör.
|
||||
|
||||
// Count visar hur många värden som finns i listan.
|
||||
// Sort sorterar värdena i listan. Text sorteras normalt i bokstavsordning
|
||||
// och tal sorteras normalt från det minsta till det största.
|
||||
// Contains kontrollerar om ett visst värde finns i listan och ger true eller false.
|
||||
|
||||
List<string> namn = new List<string>
|
||||
{
|
||||
"Cecilia",
|
||||
"Anna",
|
||||
"Bo"
|
||||
};
|
||||
|
||||
Console.WriteLine($"Antal namn: {namn.Count}");
|
||||
|
||||
namn.Sort();
|
||||
|
||||
foreach (string person in namn)
|
||||
{
|
||||
Console.WriteLine(person);
|
||||
}
|
||||
|
||||
if (namn.Contains("Anna"))
|
||||
{
|
||||
Console.WriteLine("Anna finns i listan");
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
// Förklara skillnaden mellan att använda en for-loop och en foreach-loop för att gå igenom en lista. När kan en for-loop vara ett bättre val?
|
||||
|
||||
// En for-loop använder ett index för att gå igenom listan.
|
||||
// Därför kan man komma åt både värdet och dess position.
|
||||
//
|
||||
// En foreach-loop går direkt igenom värdena utan att man behöver hantera index.
|
||||
// Den är ofta enklare när man bara vill läsa eller skriva ut alla värden.
|
||||
//
|
||||
// En for-loop är ett bättre val när man behöver använda indexet eller ändra
|
||||
// ett värde på en viss position i listan.
|
||||
|
||||
List<string> namn = new List<string>
|
||||
{
|
||||
"Anna",
|
||||
"Bo",
|
||||
"Cecilia"
|
||||
};
|
||||
|
||||
for (int i = 0; i < namn.Count; i++)
|
||||
{
|
||||
Console.WriteLine($"Index {i}: {namn[i]}");
|
||||
}
|
||||
|
||||
foreach (string person in namn)
|
||||
{
|
||||
Console.WriteLine(person);
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
// Vad är en Dictionary, och vad menas med att den innehåller nyckel- och värdepar? Varför måste varje nyckel vara unik?
|
||||
|
||||
// En Dictionary lagrar information som nyckel- och värdepar.
|
||||
// Nyckeln används för att hitta det värde som hör till nyckeln.
|
||||
//
|
||||
// Varje nyckel måste vara unik eftersom programmet annars inte skulle veta
|
||||
// vilket värde som ska hämtas när nyckeln används.
|
||||
|
||||
Dictionary<string, string> huvudstader = new Dictionary<string, string>
|
||||
{
|
||||
{ "Sverige", "Stockholm" },
|
||||
{ "Norge", "Oslo" },
|
||||
{ "Danmark", "Köpenhamn" }
|
||||
};
|
||||
|
||||
Console.WriteLine(huvudstader["Sverige"]);
|
||||
@@ -0,0 +1,20 @@
|
||||
// Vad används try-catch till? Förklara också varför try-catch inte bör användas som ersättning för vanlig logik i ett program.
|
||||
|
||||
// try-catch används för att hantera fel som kan inträffa när programmet körs.
|
||||
// Koden som kan orsaka ett fel placeras i try. Om ett fel inträffar körs catch.
|
||||
//
|
||||
// try-catch bör inte ersätta vanlig logik eftersom förväntade situationer oftast
|
||||
// kan kontrolleras med exempelvis if-satser eller TryParse. Undantag bör främst
|
||||
// användas för oväntade fel, inte för programmets normala styrning.
|
||||
|
||||
Console.Write("Ange ett heltal: ");
|
||||
|
||||
try
|
||||
{
|
||||
int tal = int.Parse(Console.ReadLine());
|
||||
Console.WriteLine($"Du skrev {tal}");
|
||||
}
|
||||
catch (FormatException)
|
||||
{
|
||||
Console.WriteLine("Du skrev inte ett giltigt heltal");
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
// Vad menas med god programmeringssed? Resonera kring varför tydliga variabelnamn, konstanter och lagom många kommentarer gör kod lättare för andra programmerare att förstå och underhålla.
|
||||
|
||||
// God programmeringssed innebär att skriva kod som är tydlig, strukturerad
|
||||
// och lätt att förstå och ändra.
|
||||
//
|
||||
// Beskrivande variabelnamn visar vad värdena används till. Ett namn som antalElever
|
||||
// är tydligare än exempelvis x.
|
||||
//
|
||||
// Konstanter passar för värden som inte ska förändras. De ger värdet ett tydligt
|
||||
// namn och gör det enklare att ändra värdet på ett enda ställe.
|
||||
//
|
||||
// Kommentarer bör förklara sådant som inte är självklart, till exempel varför en
|
||||
// viss lösning används. För många kommentarer kan däremot göra koden svårare att läsa.
|
||||
|
||||
const int MaxAntalElever = 30;
|
||||
int antalRegistreradeElever = 24;
|
||||
|
||||
if (antalRegistreradeElever < MaxAntalElever)
|
||||
{
|
||||
Console.WriteLine("Det finns lediga platser");
|
||||
}
|
||||
else
|
||||
{
|
||||
Console.WriteLine("Kursen är full");
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
// Vad är en sträng i C#? Förklara vad det innebär att en sträng är en samling tecken och att strängar är oföränderliga.
|
||||
|
||||
// En sträng används för att lagra text och har datatypen string i C#.
|
||||
// Strängen består av en samling tecken, till exempel bokstäver, siffror och blanksteg.
|
||||
//
|
||||
// Att strängar är oföränderliga betyder att innehållet i en befintlig sträng
|
||||
// inte kan ändras. När en sträng verkar ändras skapas egentligen en ny sträng.
|
||||
|
||||
string text = "Hej";
|
||||
text = text + " världen";
|
||||
|
||||
Console.WriteLine(text);
|
||||
@@ -0,0 +1,14 @@
|
||||
// Hur fungerar indexering av strängar? Vilket index har det första tecknet, och hur kan du komma åt ett enskilt tecken i en sträng?
|
||||
|
||||
// Varje tecken i en sträng har ett index som visar tecknets position.
|
||||
// Det första tecknet har index 0, det andra har index 1 och så vidare.
|
||||
// Ett enskilt tecken hämtas genom att skriva strängens namn följt av indexet
|
||||
// inom hakparenteser.
|
||||
|
||||
string ord = "Citron";
|
||||
|
||||
char forstaTecknet = ord[0];
|
||||
char tredjeTecknet = ord[2];
|
||||
|
||||
Console.WriteLine(forstaTecknet); // C
|
||||
Console.WriteLine(tredjeTecknet); // t
|
||||
@@ -0,0 +1,9 @@
|
||||
// Skriv ett C#-program som ber användaren skriva in ett ord och sedan skriver ut varje tecken på en egen rad med hjälp av en foreach-loop.
|
||||
|
||||
Console.Write("Skriv ett ord: ");
|
||||
string ord = Console.ReadLine();
|
||||
|
||||
foreach (char tecken in ord)
|
||||
{
|
||||
Console.WriteLine(tecken);
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
// Förklara skillnaden mellan strängkonkatenering och stränginterpolering. Ge ett exempel på en utskrift där ett förnamn, ett efternamn och en ålder används.
|
||||
|
||||
// Strängkonkatenering innebär att strängar och värden sätts ihop med operatorn +.
|
||||
// Stränginterpolering innebär att variabler placeras direkt i en sträng inom
|
||||
// klammerparenteser. En interpolerad sträng börjar med tecknet $.
|
||||
|
||||
string fornamn = "Anna";
|
||||
string efternamn = "Andersson";
|
||||
int alder = 25;
|
||||
|
||||
Console.WriteLine("Jag heter " + fornamn + " " + efternamn + " och är " + alder + " år.");
|
||||
Console.WriteLine($"Jag heter {fornamn} {efternamn} och är {alder} år.");
|
||||
@@ -0,0 +1,13 @@
|
||||
// Vad används metoderna eller egenskaperna Length, Substring, ToUpper och ToLower till? Beskriv vad var och en gör.
|
||||
|
||||
// Length visar hur många tecken som finns i en sträng.
|
||||
// Substring hämtar en del av en sträng från en angiven position.
|
||||
// ToUpper skapar en ny sträng där bokstäverna har omvandlats till stora bokstäver.
|
||||
// ToLower skapar en ny sträng där bokstäverna har omvandlats till små bokstäver.
|
||||
|
||||
string text = "Programmering";
|
||||
|
||||
Console.WriteLine(text.Length);
|
||||
Console.WriteLine(text.Substring(0, 7));
|
||||
Console.WriteLine(text.ToUpper());
|
||||
Console.WriteLine(text.ToLower());
|
||||
@@ -0,0 +1,12 @@
|
||||
// Förklara skillnaden mellan Split och Join. Skriv ett program som delar upp texten ”röd,grön,blå” vid kommatecknen och sedan sätter ihop orden igen med ett lodrätt streck mellan varje ord.
|
||||
|
||||
// Split delar upp en sträng i flera delar vid ett angivet tecken eller en angiven text.
|
||||
// Resultatet blir en array med strängar.
|
||||
// Join sätter ihop flera strängar till en ny sträng och placerar en avskiljare
|
||||
// mellan varje värde.
|
||||
|
||||
string text = "röd,grön,blå";
|
||||
string[] farger = text.Split(',');
|
||||
string resultat = string.Join("|", farger);
|
||||
|
||||
Console.WriteLine(resultat);
|
||||
@@ -0,0 +1,10 @@
|
||||
// Skriv ett C#-program som ber användaren skriva in en mening. Programmet ska ta bort blanksteg i början och slutet, omvandla meningen till stora bokstäver samt skriva ut antalet tecken.
|
||||
|
||||
Console.Write("Skriv en mening: ");
|
||||
string mening = Console.ReadLine();
|
||||
|
||||
mening = mening.Trim();
|
||||
mening = mening.ToUpper();
|
||||
|
||||
Console.WriteLine(mening);
|
||||
Console.WriteLine($"Antal tecken: {mening.Length}");
|
||||
@@ -0,0 +1,19 @@
|
||||
// Vad är skillnaden mellan Parse och TryParse? Förklara varför TryParse kan vara ett säkrare val när ett program ska omvandla användarens text till ett tal.
|
||||
|
||||
// Parse försöker omvandla en sträng till en viss datatyp. Om texten inte kan
|
||||
// omvandlas uppstår ett fel och programmet kan avslutas.
|
||||
//
|
||||
// TryParse försöker också omvandla texten, men ger true om det lyckas och false
|
||||
// om det misslyckas. Därför kan programmet hantera felaktig inmatning utan att krascha.
|
||||
|
||||
Console.Write("Ange ett heltal: ");
|
||||
string text = Console.ReadLine();
|
||||
|
||||
if (int.TryParse(text, out int tal))
|
||||
{
|
||||
Console.WriteLine($"Du skrev talet {tal}");
|
||||
}
|
||||
else
|
||||
{
|
||||
Console.WriteLine("Du skrev inte ett giltigt heltal");
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
// Vad är en metod? Nämn två fördelar med att dela upp ett program i metoder.
|
||||
|
||||
// En metod är ett namngivet kodblock som utför en viss uppgift.
|
||||
// Två fördelar är att kod kan återanvändas och att programmet blir lättare
|
||||
// att läsa, felsöka och underhålla.
|
||||
|
||||
void SkrivHej()
|
||||
{
|
||||
Console.WriteLine("Hej!");
|
||||
}
|
||||
|
||||
SkrivHej();
|
||||
@@ -0,0 +1,11 @@
|
||||
// Vad är skillnaden mellan att definiera en metod och att anropa den?
|
||||
|
||||
// Att definiera en metod innebär att skriva metoden och bestämma vad den ska göra.
|
||||
// Att anropa metoden innebär att be programmet att köra koden i metoden.
|
||||
|
||||
void SkrivHej()
|
||||
{
|
||||
Console.WriteLine("Hej!");
|
||||
}
|
||||
|
||||
SkrivHej(); // Metoden anropas
|
||||
@@ -0,0 +1,13 @@
|
||||
// Vilka delar måste en metoddefinition innehålla? Förklara kort vad returtypen, namnet och metodkroppen anger.
|
||||
|
||||
// Returtypen anger vilken typ av värde metoden returnerar. void betyder att
|
||||
// metoden inte returnerar något värde.
|
||||
// Namnet används för att identifiera och anropa metoden.
|
||||
// Metodkroppen är koden mellan { och } som körs när metoden anropas.
|
||||
|
||||
void SkrivMeddelande()
|
||||
{
|
||||
Console.WriteLine("Detta är metodens kropp");
|
||||
}
|
||||
|
||||
SkrivMeddelande();
|
||||
@@ -0,0 +1,8 @@
|
||||
// Skriv en metod som skriver ut ditt för- och efternamn. Anropa metoden så att texten skrivs ut.
|
||||
|
||||
void SkrivNamn()
|
||||
{
|
||||
Console.WriteLine("Christian Ohlsson");
|
||||
}
|
||||
|
||||
SkrivNamn();
|
||||
@@ -0,0 +1,19 @@
|
||||
// Vad innebär scope för en metods lokala variabler? Kan en lokal variabel i en metod användas direkt i en annan metod? Förklara varför.
|
||||
|
||||
// En lokal variabel har bara scope inom den metod där den deklareras.
|
||||
// Den kan därför inte användas direkt i en annan metod eftersom variabeln
|
||||
// inte är tillgänglig utanför sitt eget kodblock.
|
||||
|
||||
void MetodEtt()
|
||||
{
|
||||
int tal = 10;
|
||||
Console.WriteLine(tal);
|
||||
}
|
||||
|
||||
void MetodTva()
|
||||
{
|
||||
// Console.WriteLine(tal); // Fungerar inte. tal finns bara i MetodEtt.
|
||||
}
|
||||
|
||||
MetodEtt();
|
||||
MetodTva();
|
||||
@@ -0,0 +1,11 @@
|
||||
// Förklara skillnaden mellan en parameter och ett argument?
|
||||
|
||||
// En parameter är variabeln som anges i metodens definition.
|
||||
// Ett argument är det värde som skickas till metoden när den anropas.
|
||||
|
||||
void SkrivNamn(string namn) // namn är en parameter
|
||||
{
|
||||
Console.WriteLine(namn);
|
||||
}
|
||||
|
||||
SkrivNamn("Anna"); // "Anna" är ett argument
|
||||
@@ -0,0 +1,12 @@
|
||||
// Vad är skillnaden mellan en metods returtyp och dess returvärde?
|
||||
|
||||
// Returtypen anger vilken datatyp metoden ska returnera, till exempel int.
|
||||
// Returvärdet är det faktiska värde som skickas tillbaka med return.
|
||||
|
||||
int HamtaTal()
|
||||
{
|
||||
return 10;
|
||||
}
|
||||
|
||||
int tal = HamtaTal();
|
||||
Console.WriteLine(tal);
|
||||
@@ -0,0 +1,9 @@
|
||||
// Skriv en metod som tar emot ett heltal, dubblerar det och returnerar resultatet. Visa också hur du anropar metoden och sparar returvärdet i en variabel.
|
||||
|
||||
int Dubblera(int tal)
|
||||
{
|
||||
return tal * 2;
|
||||
}
|
||||
|
||||
int resultat = Dubblera(5);
|
||||
Console.WriteLine(resultat);
|
||||
@@ -0,0 +1,12 @@
|
||||
// Vad är skillnaden mellan en parameter och ett argument? Om en metod har parametrarna string name och int age, i vilken ordning ska argumenten skickas in?
|
||||
|
||||
// En parameter är variabeln som anges i metodens definition.
|
||||
// Ett argument är värdet som skickas till metoden när den anropas.
|
||||
// Argumenten ska normalt skickas i samma ordning som parametrarna är definierade.
|
||||
|
||||
void Presentera(string name, int age)
|
||||
{
|
||||
Console.WriteLine($"{name} är {age} år.");
|
||||
}
|
||||
|
||||
Presentera("Anna", 25);
|
||||
@@ -0,0 +1,17 @@
|
||||
// Vad innebär överlagring av metoder? Skriv ett exempel på två metoder med samma namn men olika parameterlistor.
|
||||
|
||||
// Överlagring innebär att flera metoder kan ha samma namn om deras parameterlistor skiljer sig åt.
|
||||
// C# avgör vilken metod som ska användas beroende på argumenten vid anropet.
|
||||
|
||||
void SkrivUt(string text)
|
||||
{
|
||||
Console.WriteLine(text);
|
||||
}
|
||||
|
||||
void SkrivUt(int tal)
|
||||
{
|
||||
Console.WriteLine(tal);
|
||||
}
|
||||
|
||||
SkrivUt("Hej");
|
||||
SkrivUt(10);
|
||||
@@ -0,0 +1,15 @@
|
||||
// Vad är en värdetyp? Ge två exempel från C# och förklara vad som händer när en värdetyp skickas till en metod.
|
||||
|
||||
// En värdetyp lagrar själva värdet. Exempel på värdetyper är int och bool.
|
||||
// När en värdetyp skickas till en metod skickas normalt en kopia av värdet.
|
||||
// Om parametern ändras i metoden påverkas därför inte originalvariabeln.
|
||||
|
||||
int tal = 5;
|
||||
Dubblera(tal);
|
||||
Console.WriteLine(tal); // 5
|
||||
|
||||
void Dubblera(int nummer)
|
||||
{
|
||||
nummer = nummer * 2;
|
||||
Console.WriteLine(nummer); // 10
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
// Vad är en referenstyp? Ge två exempel och förklara varför en ändring av ett element i en array inuti en metod kan märkas efter att metoden har avslutats.
|
||||
|
||||
// En referenstyp lagrar en referens till ett objekt i minnet. Exempel är arrayer och List.
|
||||
// När en array skickas till en metod får metoden en kopia av referensen till samma array.
|
||||
// Därför kan en ändring av ett element i arrayen märkas även efter att metoden avslutats.
|
||||
|
||||
int[] tal = { 1, 2, 3 };
|
||||
AndraForsta(tal);
|
||||
Console.WriteLine(tal[0]); // 100
|
||||
|
||||
void AndraForsta(int[] nummer)
|
||||
{
|
||||
nummer[0] = 100;
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
// Vad skrivs ut av följande program? Förklara varför värdet i number utanför metoden påverkas eller inte påverkas.
|
||||
|
||||
// Programmet skriver först ut 10 inne i metoden och därefter 5 utanför metoden.
|
||||
// int är en värdetyp. När number skickas till Print får metoden en kopia av värdet.
|
||||
// Ändringen till 10 påverkar därför bara metodens lokala parameter.
|
||||
|
||||
int number = 5;
|
||||
Print(number);
|
||||
Console.WriteLine(number); // 5
|
||||
|
||||
void Print(int number)
|
||||
{
|
||||
number = number * 2;
|
||||
Console.WriteLine(number); // 10
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
// Vad är en rekursiv metod? Skriv en metod som räknar upp från ett angivet heltal till 5 genom att anropa sig själv.
|
||||
|
||||
// En rekursiv metod är en metod som anropar sig själv.
|
||||
|
||||
RaknaTillFem(1);
|
||||
|
||||
void RaknaTillFem(int tal)
|
||||
{
|
||||
if (tal > 5)
|
||||
return;
|
||||
|
||||
Console.WriteLine(tal);
|
||||
RaknaTillFem(tal + 1);
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
// Vad är ett basfall i rekursion? Vad kan hända om en rekursiv metod saknar ett villkor som stoppar anropen?
|
||||
|
||||
// Ett basfall är villkoret som avslutar rekursionen och gör att metoden slutar anropa sig själv.
|
||||
// Utan ett basfall kan anropen fortsätta tills programmets anropsstack tar slut,
|
||||
// vilket normalt leder till StackOverflowException och att programmet avslutas.
|
||||
|
||||
RaknaNer(3);
|
||||
|
||||
void RaknaNer(int tal)
|
||||
{
|
||||
if (tal == 0) // Basfall
|
||||
return;
|
||||
|
||||
Console.WriteLine(tal);
|
||||
RaknaNer(tal - 1);
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
// Beskriv en likhet och en skillnad mellan att använda rekursion och att använda en loop för att upprepa kod.
|
||||
|
||||
// Likhet: både rekursion och loopar kan användas för att upprepa en uppgift flera gånger.
|
||||
// Skillnad: en loop upprepar ett kodblock med exempelvis for eller while,
|
||||
// medan rekursion innebär att en metod anropar sig själv.
|
||||
// Rekursion använder dessutom anropsstacken för varje nytt metodanrop.
|
||||
|
||||
for (int i = 1; i <= 3; i++)
|
||||
{
|
||||
Console.WriteLine(i);
|
||||
}
|
||||
|
||||
SkrivTal(1);
|
||||
|
||||
void SkrivTal(int tal)
|
||||
{
|
||||
if (tal > 3)
|
||||
return;
|
||||
|
||||
Console.WriteLine(tal);
|
||||
SkrivTal(tal + 1);
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
// Varför kan det vara bra att bryta ut programlogik i egna metoder? Förklara hur detta kan göra koden tydligare och enklare att återanvända.
|
||||
|
||||
// Genom att dela upp programmet i metoder får varje metod en tydlig uppgift.
|
||||
// Det gör koden lättare att läsa, testa och underhålla.
|
||||
// Kod som används flera gånger kan dessutom placeras i en metod och återanvändas
|
||||
// genom att metoden anropas från flera ställen i programmet.
|
||||
|
||||
void SkrivHalsning()
|
||||
{
|
||||
Console.WriteLine("Hej!");
|
||||
}
|
||||
|
||||
SkrivHalsning();
|
||||
SkrivHalsning();
|
||||
@@ -0,0 +1,12 @@
|
||||
// Skriv en metod som tar emot två strängar som parametrar och returnerar den sträng som är längst. Hur kan du testa metoden från programmets huvudflöde?
|
||||
|
||||
string Langst(string text1, string text2)
|
||||
{
|
||||
if (text1.Length >= text2.Length)
|
||||
return text1;
|
||||
else
|
||||
return text2;
|
||||
}
|
||||
|
||||
string resultat = Langst("Programmering", "Csharp");
|
||||
Console.WriteLine(resultat);
|
||||
@@ -0,0 +1,15 @@
|
||||
// Skriv en metod som tar emot en sträng och returnerar en ny sträng där tecknen kommer i omvänd ordning. Försök lösa uppgiften med hjälp av en loop.
|
||||
|
||||
string VandText(string text)
|
||||
{
|
||||
string resultat = "";
|
||||
|
||||
for (int i = text.Length - 1; i >= 0; i--)
|
||||
{
|
||||
resultat += text[i];
|
||||
}
|
||||
|
||||
return resultat;
|
||||
}
|
||||
|
||||
Console.WriteLine(VandText("Christian"));
|
||||
@@ -0,0 +1,17 @@
|
||||
// Skriv en metod som tar emot ett tecken och en sträng. Metoden ska räkna hur många gånger tecknet förekommer i strängen och returnera antalet.
|
||||
|
||||
int RaknaTecken(char tecken, string text)
|
||||
{
|
||||
int antal = 0;
|
||||
|
||||
foreach (char aktuelltTecken in text)
|
||||
{
|
||||
if (aktuelltTecken == tecken)
|
||||
antal++;
|
||||
}
|
||||
|
||||
return antal;
|
||||
}
|
||||
|
||||
int resultat = RaknaTecken('a', "banan");
|
||||
Console.WriteLine(resultat);
|
||||
@@ -0,0 +1,18 @@
|
||||
// Skriv en metod som kontrollerar om en sträng endast innehåller siffror. Metoden ska returnera true om alla tecken är siffror och annars returnera false.
|
||||
|
||||
bool EndastSiffror(string text)
|
||||
{
|
||||
if (text.Length == 0)
|
||||
return false;
|
||||
|
||||
foreach (char tecken in text)
|
||||
{
|
||||
if (!char.IsDigit(tecken))
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
Console.WriteLine(EndastSiffror("12345")); // true
|
||||
Console.WriteLine(EndastSiffror("12A45")); // false
|
||||
@@ -0,0 +1,12 @@
|
||||
// Skriv en metod som tar emot ett ord och returnerar ordet med stor första bokstav. Fundera även på vad som händer om metoden får en tom sträng.
|
||||
|
||||
string StorForstaBokstav(string ord)
|
||||
{
|
||||
if (ord.Length == 0)
|
||||
return "";
|
||||
|
||||
return char.ToUpper(ord[0]) + ord.Substring(1);
|
||||
}
|
||||
|
||||
Console.WriteLine(StorForstaBokstav("programmering"));
|
||||
Console.WriteLine(StorForstaBokstav(""));
|
||||
@@ -0,0 +1,18 @@
|
||||
// Vad är ett palindrom? Skriv en metod som kontrollerar om en text är likadan framlänges och baklänges.
|
||||
|
||||
// Ett palindrom är en text som blir likadan om den läses framlänges och baklänges,
|
||||
// till exempel "anna" eller "radar".
|
||||
|
||||
bool ArPalindrom(string text)
|
||||
{
|
||||
for (int i = 0; i < text.Length / 2; i++)
|
||||
{
|
||||
if (text[i] != text[text.Length - 1 - i])
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
Console.WriteLine(ArPalindrom("radar")); // true
|
||||
Console.WriteLine(ArPalindrom("hej")); // false
|
||||
@@ -0,0 +1,9 @@
|
||||
// Vad är en fil, och varför används filer i ett program? Förklara vad som menas med permanent lagring mellan programkörningar.
|
||||
|
||||
// En fil är information som lagras på exempelvis en hårddisk eller SSD.
|
||||
// Program använder filer för att kunna spara och läsa information.
|
||||
// Permanent lagring innebär att informationen finns kvar även efter att
|
||||
// programmet har avslutats och kan läsas in nästa gång programmet körs.
|
||||
|
||||
string filnamn = "data.txt";
|
||||
File.WriteAllText(filnamn, "Detta sparas i en fil.");
|
||||
@@ -0,0 +1,13 @@
|
||||
// Vad är skillnaden mellan en absolut och en relativ filväg? Ge ett exempel på vardera.
|
||||
|
||||
// En absolut filväg anger hela vägen till filen från filsystemets början.
|
||||
// Exempel i Windows: C:\Users\Christian\Documents\data.txt
|
||||
//
|
||||
// En relativ filväg utgår från programmets aktuella arbetskatalog.
|
||||
// Exempel: data\data.txt
|
||||
|
||||
string absolut = @"C:/Users/Christian/Documents/data.txt";
|
||||
string relativ = @"data/data.txt";
|
||||
|
||||
Console.WriteLine(absolut);
|
||||
Console.WriteLine(relativ);
|
||||
@@ -0,0 +1,15 @@
|
||||
// Förklara skillnaden mellan File.WriteAllText och StreamWriter. När kan det vara lämpligt att använda respektive alternativ?
|
||||
|
||||
// File.WriteAllText skriver en hel text till en fil på en gång.
|
||||
// Det passar bra när mängden text är liten och allt innehåll redan finns tillgängligt.
|
||||
//
|
||||
// StreamWriter kan skriva information steg för steg och passar därför bra när
|
||||
// större mängder data eller flera rader ska skrivas efter hand.
|
||||
|
||||
File.WriteAllText("fil1.txt", "Hej från WriteAllText!");
|
||||
|
||||
using (StreamWriter writer = new StreamWriter("fil2.txt"))
|
||||
{
|
||||
writer.WriteLine("Första raden");
|
||||
writer.WriteLine("Andra raden");
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
// Skriv ett C#-program som skapar en textfil, skriver två rader till filen och sedan läser in och skriver ut filens innehåll på skärmen.
|
||||
|
||||
string filnamn = "text.txt";
|
||||
|
||||
using (StreamWriter writer = new StreamWriter(filnamn))
|
||||
{
|
||||
writer.WriteLine("Första raden");
|
||||
writer.WriteLine("Andra raden");
|
||||
}
|
||||
|
||||
string innehall = File.ReadAllText(filnamn);
|
||||
Console.WriteLine(innehall);
|
||||
@@ -0,0 +1,12 @@
|
||||
// Vad är skillnaden mellan att skriva över en fil och att lägga till text i append-läge? Beskriv hur StreamWriter kan användas för att lägga till en ny rad utan att det befintliga innehållet försvinner.
|
||||
|
||||
// När en fil skrivs över ersätts det tidigare innehållet.
|
||||
// I append-läge läggs den nya texten sist i filen och det gamla innehållet behålls.
|
||||
// StreamWriter kan öppnas med true som andra argument för att använda append-läge.
|
||||
|
||||
string filnamn = "logg.txt";
|
||||
|
||||
using (StreamWriter writer = new StreamWriter(filnamn, true))
|
||||
{
|
||||
writer.WriteLine("En ny rad läggs till i filen.");
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
// Varför används using tillsammans med StreamReader och StreamWriter? Vad kan hända om en fil inte stängs korrekt?
|
||||
|
||||
// using ser till att StreamReader eller StreamWriter stängs automatiskt när
|
||||
// kodblocket är färdigt, även om ett fel skulle uppstå.
|
||||
// Om en fil inte stängs korrekt kan resurser bli kvar, data kanske inte skrivs
|
||||
// färdigt och andra program kan få problem att öppna filen.
|
||||
|
||||
using (StreamWriter writer = new StreamWriter("data.txt"))
|
||||
{
|
||||
writer.WriteLine("Hej!");
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
// Vilka fel kan uppstå när ett program arbetar med filer? Beskriv hur File.Exists och try-catch kan användas för att hantera några av dessa problem.
|
||||
|
||||
// En fil kan saknas, sökvägen kan vara felaktig eller programmet kan sakna
|
||||
// behörighet att läsa eller skriva filen.
|
||||
// File.Exists kan användas för att kontrollera att en fil finns innan den läses.
|
||||
// try-catch kan fånga fel som ändå uppstår och visa ett tydligt felmeddelande.
|
||||
|
||||
string filnamn = "data.txt";
|
||||
|
||||
if (File.Exists(filnamn))
|
||||
{
|
||||
try
|
||||
{
|
||||
string innehall = File.ReadAllText(filnamn);
|
||||
Console.WriteLine(innehall);
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
Console.WriteLine($"Det gick inte att läsa filen: {e.Message}");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Console.WriteLine("Filen finns inte.");
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
// Skriv ett C#-program som tar emot ett filnamn som argument från terminalen. Programmet ska kontrollera att ett argument har angetts och att filen finns. Om filen finns ska innehållet skrivas ut, annars ska ett tydligt felmeddelande visas.
|
||||
|
||||
if (args.Length == 0)
|
||||
{
|
||||
Console.WriteLine("Fel: Du måste ange ett filnamn.");
|
||||
return;
|
||||
}
|
||||
|
||||
string filnamn = args[0];
|
||||
|
||||
if (!File.Exists(filnamn))
|
||||
{
|
||||
Console.WriteLine($"Fel: Filen '{filnamn}' finns inte.");
|
||||
return;
|
||||
}
|
||||
|
||||
string innehall = File.ReadAllText(filnamn);
|
||||
Console.WriteLine(innehall);
|
||||
@@ -0,0 +1,21 @@
|
||||
// Vad innebär objektorienterad programmering? Förklara hur data och funktionalitet grupperas tillsammans för att representera objekt.
|
||||
|
||||
// Objektorienterad programmering innebär att ett program byggs upp av objekt.
|
||||
// Ett objekt samlar data och funktionalitet som hör ihop.
|
||||
// Data lagras exempelvis i properties och funktionaliteten skrivs som metoder.
|
||||
// Ett objekt av klassen Bil kan till exempel innehålla data om färg och hastighet
|
||||
// samt metoder för att köra och bromsa.
|
||||
|
||||
Bil bil = new Bil();
|
||||
bil.Farg = "Röd";
|
||||
bil.Kor();
|
||||
|
||||
class Bil
|
||||
{
|
||||
public string Farg { get; set; }
|
||||
|
||||
public void Kor()
|
||||
{
|
||||
Console.WriteLine($"Den {Farg.ToLower()}a bilen kör.");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
// Vad är skillnaden mellan en klass och ett objekt? Använd gärna liknelsen med en ritning, mall eller ett recept i din förklaring.
|
||||
|
||||
// En klass är en mall eller ritning som beskriver vilka egenskaper och metoder
|
||||
// en viss typ av objekt ska ha.
|
||||
// Ett objekt är ett konkret exemplar som har skapats utifrån klassen.
|
||||
// På samma sätt som en husritning kan användas för att bygga flera hus kan en
|
||||
// klass användas för att skapa flera objekt.
|
||||
|
||||
Bil forstaBilen = new Bil();
|
||||
Bil andraBilen = new Bil();
|
||||
|
||||
class Bil
|
||||
{
|
||||
public string Farg { get; set; }
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
// Vad är en konstruktor, och när körs den? Förklara även varför en konstruktor kan ha parametrar.
|
||||
|
||||
// En konstruktor är en särskild metod som körs automatiskt när ett objekt skapas.
|
||||
// Konstruktorn har samma namn som klassen och saknar returtyp.
|
||||
// Parametrar gör att objektet kan få startvärden direkt när det skapas.
|
||||
|
||||
Person person = new Person("Anna", 25);
|
||||
Console.WriteLine($"{person.Namn} är {person.Alder} år.");
|
||||
|
||||
class Person
|
||||
{
|
||||
public string Namn { get; set; }
|
||||
public int Alder { get; set; }
|
||||
|
||||
public Person(string namn, int alder)
|
||||
{
|
||||
Namn = namn;
|
||||
Alder = alder;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
// Vad är properties i C#, och vad används get och set till? Förklara varför properties ofta är bättre än publika fält.
|
||||
|
||||
// Properties används för att läsa och ändra data som hör till ett objekt.
|
||||
// get används när värdet läses och set används när värdet tilldelas.
|
||||
// Properties är ofta bättre än publika fält eftersom åtkomsten kan kontrolleras.
|
||||
// Man kan exempelvis validera ett nytt värde eller göra set privat.
|
||||
|
||||
Person person = new Person();
|
||||
person.Namn = "Anna";
|
||||
Console.WriteLine(person.Namn);
|
||||
|
||||
class Person
|
||||
{
|
||||
public string Namn { get; set; }
|
||||
|
||||
private int alder;
|
||||
|
||||
public int Alder
|
||||
{
|
||||
get { return alder; }
|
||||
set
|
||||
{
|
||||
if (value >= 0)
|
||||
alder = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
// Skapa en klass som heter Bok. Klassen ska ha egenskaper för titel, författare, antal sidor och om boken är utlånad. Lägg även till en konstruktor och en metod som skriver ut information om boken.
|
||||
|
||||
Bok bok = new Bok("1984", "George Orwell", 328, false);
|
||||
bok.SkrivInformation();
|
||||
|
||||
class Bok
|
||||
{
|
||||
public string Titel { get; set; }
|
||||
public string Forfattare { get; set; }
|
||||
public int AntalSidor { get; set; }
|
||||
public bool ArUtlanad { get; set; }
|
||||
|
||||
public Bok(string titel, string forfattare, int antalSidor, bool arUtlanad)
|
||||
{
|
||||
Titel = titel;
|
||||
Forfattare = forfattare;
|
||||
AntalSidor = antalSidor;
|
||||
ArUtlanad = arUtlanad;
|
||||
}
|
||||
|
||||
public void SkrivInformation()
|
||||
{
|
||||
Console.WriteLine($"Titel: {Titel}");
|
||||
Console.WriteLine($"Författare: {Forfattare}");
|
||||
Console.WriteLine($"Antal sidor: {AntalSidor}");
|
||||
Console.WriteLine($"Utlånad: {ArUtlanad}");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
// Skapa en klass som heter Rektangel med egenskaperna Höjd och Bredd. Lägg till en metod som beräknar och returnerar rektangelns area. Skapa sedan ett objekt av klassen och anropa metoden.
|
||||
|
||||
Rektangel rektangel = new Rektangel();
|
||||
rektangel.Hojd = 5;
|
||||
rektangel.Bredd = 8;
|
||||
|
||||
double area = rektangel.BeraknaArea();
|
||||
Console.WriteLine($"Rektangelns area är {area}.");
|
||||
|
||||
class Rektangel
|
||||
{
|
||||
public double Hojd { get; set; }
|
||||
public double Bredd { get; set; }
|
||||
|
||||
public double BeraknaArea()
|
||||
{
|
||||
return Hojd * Bredd;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
// Vad betyder static i C#? Förklara skillnaden mellan något som tillhör klassen och något som tillhör ett enskilt objekt.
|
||||
|
||||
// static betyder att något tillhör själva klassen i stället för ett enskilt objekt.
|
||||
// En statisk medlem används genom klassens namn och delas av alla objekt.
|
||||
// En instansmedlem tillhör däremot ett visst objekt och kan ha olika värden
|
||||
// i olika objekt.
|
||||
|
||||
Person forstaPersonen = new Person("Anna");
|
||||
Person andraPersonen = new Person("Bo");
|
||||
|
||||
Console.WriteLine(forstaPersonen.Namn);
|
||||
Console.WriteLine(andraPersonen.Namn);
|
||||
Console.WriteLine(Person.AntalPersoner);
|
||||
|
||||
class Person
|
||||
{
|
||||
public string Namn { get; set; }
|
||||
public static int AntalPersoner { get; private set; }
|
||||
|
||||
public Person(string namn)
|
||||
{
|
||||
Namn = namn;
|
||||
AntalPersoner++;
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user