Lunds universitet FYTA11 Institutionen för Astronomi och Teoretisk fysik HT 14 Lösningsförslag FYTA11 Javaprogrammering Fredag 19 december 2014, 10:15 14:15 Instruktioner Hjälpmedel: Papper och penna. Behandla högst en uppgift per papper och sätt ditt namn och uppgiftens nummer på varje papper. Skriv läsligt och kommentera utförligt vad du gör det kan ge dig poäng även om resultatet blir fel. Tentamen omfattar fyra uppgifter som vardera kan ge upp till tio poäng. För G och VG krävs 20 respektive 30 poäng, inräknat de högst fem bonuspoängen från simuleringsövningarna. Uppgift 1: Små fel Korrigera felen i följande kodstycken där felens natur anges av kommentarer i/efter koden. a. b. c. for(int i = 0, i < 10, ++i) // fel for(int i = 0; i < 10; ++i) // rätt //... // error: ; expected // error: illegal start of type // error: illegal start of expression int steps; // fel int steps = 0; // rätt while(!done()) steps++; // error: variable steps might not have been initialized public print(string s) // fel public void print(string s) // rätt System.out.println("output: " + s); // error: invalid method declaration; return type required
d. e. f. g. h. i. for(int i = 0; i < args.length(); ++i) // fel for(int i = 0; i < args.length; ++i) // rätt System.out.println(args[i]); // error: cannot find symbol // symbol: method length() switch((int)2. * Math.random()) // fel switch((int)(2. * Math.random())) // rätt /*... */ // error: possible loss of precision switch( /* enligt ovan */ ) case 0: foo(); break; // rätt case 1: bar(); // fel vid körning: anropar ibland både foo och bar public class MyListener extends ActionListener // fel public class MyListener implements ActionListener // rätt /*... */ // error: no interface expected here ArrayList<String> doubles = new ArrayList<String>; // fel ArrayList<String> doubles = new ArrayList<String>(); // rätt // error: ( or [ expected List<double> doubles; // fel List<Double> doubles; // rätt // error: unexpected type // required: reference // found: double
j. for(int i = 0; i < 10; i++) if(i % 2 == 0) for(int j = 0; i < j; j++) // fel for(int j = 0; j < i; j++) // rätt if(j % 2 == 0) System.out.println(i + " " + j); // Should print pairs of odd numbers, prints nothing // Rättelse: står udda, skulle stå jämna Uppgift 2: Finna orden I en rektangel full av bokstäver gömmer sig ett antal ord, vågrätt (från vänster) eller lodrätt (uppifrån). Du får en lista på ord och skall avgöra hur många av dem som står att finna i rektangeln. Ett exempel är detta: KNÄCKA OÖJULJ LTSCOU AMUSTL DADELF Antag att du fått en lista med de sju orden NÖT, JUL, KNÄCK, DADEL, MUST, KOLA och GRAN. Rätt svar är 6, för alla ord utom GRAN finns med. Din uppgift är att skriva en metod för att räkna hur många av orden som finns i rektangeln. Metoden skall ha följande signatur: int countwords(arraylist<string> rect, ArrayList<String> words) där rect i exemplet skulle innehålla strängarna "KNÄCKA", "OÖJULJ" och så vidare, och words skulle innehålla "NÖT", "JUL" och så vidare. Du kan förutsätta att alla strängar i rect är lika långa, och att rect innehåller minst ett tecken. Notera att ett ord kan finnas med flera gånger i rektangeln men frågan är hur många av orden som alls finns med. I klassen String finns ett antal potentiellt användbara metoder. Ett urval listas på bifogat blad. De grundläggande metoderna i ArrayList<T> bör du minnas: size(), get(int index) och add(t t).
static int countwords(arraylist<string> rect, ArrayList<String> words) // Get the size of the rectangle. int w = rect.get(0).length(); int h = rect.size(); // Transpose the words and store them in rect. // We could make a new ArrayList for this, but reusing rect works. for(int x = 0; x < w; ++x) String s = ""; for(int y = 0; y < h; ++y) s += rect.get(y).charat(x); rect.add(s); // Look for each word inside the strings in rect int found = 0; for(string wo : words) for(string rw : rect) if(rw.contains(wo)) ++found; // Count the word only once. break; return found;
Uppgift 3: Kaniner som skuttar Det skall skrivas ett program som simulerar kaniner som skuttar runt på ett fält, äter gräs, får ungar och dör. För enkelhets skull anses kaniner kunna föröka sig genom delning. Antag att ramverket för simuleringarna är färdigt och det som återstår är att skriva en klass som beskriver kaniner. Du har fått en abstrakt klass Animal som din kaninklass skall ärva från (se nästa sida). För att hantera slumptal på ett bra sätt så skall du skapa en klass AnimalSimulation vars instanser äger en slumptalsgenerator av typen java.util.random. I klassen AnimalSimulation lägger du din kaninklass Rabbit som en inre klass. Konstruktorn till Rabbit skall ta ett argument: djurets initiala energi som Animal behöver veta. Varje kanin har en ålder, ett heltal som Rabbit måste hålla reda på. Åldern för en ny kanin är 0. Metoden divisionenergy returnerar den insamlade energi som behövs för delning av en kanin. Låt denna modellparameter ha värdet 20. Metoden choosemove är den huvudsakliga metoden här. Dess uppgift är att bestämma i vilken riktning kaninen skall försöka flytta sig. Metoden är också ansvarig för att öka kaninens ålder med ett vid varje anrop. Om åldern når 50 skall choosemove returnera konstanten DEATH för att meddela att kaninen skall dö. I annat fall väljer choosemove en riktning baserat på mängden mat i den närmaste omgivningen. Världen är ett rutnät och mängden mat i de närmaste rutorna skickas som argument till choosemove så som beskrivs i kommentaren i koden. Det finns fyra möjliga riktningar (NORTH, SOUTH, EAST, WEST) att att gå i, och kaninen skall bedöma vilken av dessa riktningar som är bäst. Varje riktning poängsätts enligt följande: poängen för en riktning är dubbla mängden mat på rutan i den riktningen, plus mängden mat på den av de båda angränsande (diagonala) rutor det finns mest på. (Det finns ingen mat på den ruta där djuret redan står.) Exempel: Mat Poäng 4 2 3 8 3 * 0 10 * 3 1 0 1 1 I det här fallet skall kaninen alltså gå västerut för att 2 3+max(4,1) = 10 är mer än poängen för någon av de andra rutorna. Om det inte finns en entydigt bästa riktning så blir kaninen förvirrad och väljer en av de fyra riktningarna slumpmässigt med hjälp av Random-objektet. (Det kan vara bra att minnas att nextint(int n) ger ett heltal mindre än n.)
public abstract class Animal /** Possible moves: directions and death. */ public static final int NORTH = 0, SOUTH = 1, EAST = 2, WEST = 3, DEATH = 4; public Animal(int energy) this.energy = energy; /** Chooses a direction to move in. @param food a 3x3 array with the amount of food in the squares around this animal. The animal is at [y=1][x=1]. North is [0][1], south is [2][1], west is [1][0] and east is [1][2]. @return one of the possible directions, or death. */ public abstract int choosemove(int[][] food); /** The amount of energy needed for spawning offspring. */ protected abstract int divisionenergy(); /** increases the animal s energy level */ public void addenergy(int e) energy += e; /** returns the animal s current energy level */ public int getenergy() return energy; /** Returns true and sets energy to 0 if spawning offspring is possible */ public boolean spawnifpossible() if(energy >= divisionenergy()) energy = 0; return true; return false; // Current energy private int energy;
public class AnimalSimulation private static java.util.random rand = new java.util.random(); private class Rabbit extends Animal public Rabbit(int energy) super(energy); // anropa Animals konstruktor public int choosemove(int[][] food) if(++age >= 50) // Öka ålder, och dö om ålder > 50 return DEATH; // Poängsätt de fyra riktningarna int[] score = new int[4]; // poäng för norr: 2 * norr + max(nordväst, nordost) score[north] = 2 * food[0][1] + Math.max(food[0][0], food[0][2]); score[south] = 2 * food[2][1] + Math.max(food[2][0], food[2][2]); score[west] = 2 * food[1][0] + Math.max(food[0][0], food[2][0]); score[east] = 2 * food[1][2] + Math.max(food[0][2], food[2][2]); // Finn bästa poängen och dess riktning int best = 0; int bestdir = -1; // inte någon riktning vald än for(int i = 0; i < 4; ++i) if(score[i] > best) best = score[i]; bestdir = i; else if(score[i] == best) // om bästa poängen finns >1 gång? bestdir = -1; // ingen riktning är bäst if(bestdir == -1) // Om ingen giltig riktning, dra slumpmässig return rand.nextint(4); return bestdir; // Energin som behövs för delning protected int divisionenergy() return 20; // Instansvariabel med kaninens ålder private int age = 0;
Uppgift 4: Kaninerna skuttar vidare I denna uppgift skall du skriva färdigt programmet som simulerar kaninerna i föregående uppgift. Du får klassen AnimalSimulation som antas innehålla en fungerande implementation av klassen Rabbit. Se efterföljande två sidor. Klassen har instansvariabler för brädets storlek (width, height), vilka djur som finns på brädets rutor (animals), hur mycket mat det finns på rutorna (food) och totala antalet djur (population). Det finns en konstruktor som initierar alla instansvariabler och slumpar ut djur på brädet. Brädet har periodiska randvillkor. Metoderna xwrap och ywrap korrigerar koordinater som är negativa eller för höga, så att de hamnar inom de tillåtna intervallen. Metoden getfoodcontext använder dessa metoder när den hämtar ut information från brädet till 3x3-arrayen som skall skickas Animal.chooseMove. Det finns också metoder för att fylla på mat på brädet (updatefood) och exekvera ett tidssteg i simuleringen (oneround). Det som saknas är innehållet i metoden moveone. Denna metod skall du skriva, och den skall göra följande (som också beskrivs i kommentar i koden): 1. Först kolla så att det finns några djur att flytta. 2. Slumpa fram en position som faktiskt innehåller ett djur. 3. Anropa Animal.chooseMove med information om den lokala tillgången till mat. 4. Om djuret skall dö så skall det tas bort från brädet. 5. Annars räkna ut koordinater för den ruta djuret vill gå till. (Glöm inte att ta hänsyn till de periodiska randvillkoren; använd xwrap och ywrap.) 6. Gör inget mer om destinationsrutan är upptagen. 7. Flytta djuret till destinationsrutan. 8. Ge djuret all mat/energi som finns på destinationsrutan. (Glöm inte att ta bort maten från brädet.) 9. Om djuret har energi nog till att dela sig, skapa en ny Rabbit på rutan som djuret just kom gående från. (Det är fult att vi skapar en ny Rabbit när koden i övrigt klarar djur av andra sorter men en snygg lösning skulle kräva mer kod.)
public class AnimalSimulation private java.util.random rand = new java.util.random(); // Rabbit class goes here public AnimalSimulation(int h, int w, double popdensity) height = h; width = w; food = new int[h][w]; animals = new Animal[h][w]; for(int y = 0; y < h; ++y) for(int x = 0; x < w; ++x) if(rand.nextdouble() < popdensity) animals[y][x] = new Rabbit(0); ++population; // Returns x with periodic boundary conditions private int xwrap(int x) return (x + width) % width; // Returns y with periodic boundary conditions private int ywrap(int y) return (y + height) % height; private int[][] getfoodcontext(int y, int x) int[][] fc = new int[3][3]; for(int dx = -1; dx <= 1; ++dx) for(int dy = -1; dy <= 1; ++dy) int ny = ywrap(y + dy); int nx = xwrap(x + dx); fc[dy + 1][dx + 1] = food[ny][nx]; return fc;
private void updatefood() for(int y = 0; y < height; ++y) for(int x = 0; x < width; ++x) if(animals[y][x] == null) food[y][x]++; public void moveone() // To be implemented: // Return if no animals // Draw a random position that has an animal // Get local food context // Choose move for animal // Check for death // Find destination coordinates // Move if unoccupied destination square // Take all energy from destination square // If able to spawn, spawn new Rabbit at source position public void oneround() updatefood(); int pop = population; for(int i = 0; i < pop; ++i) moveone(); public static void main(string[] s) AnimalSimulation sim = new AnimalSimulation(100, 100,.6); for(int i = 0; i < 1000; ++i) sim.oneround(); System.out.println(i + "\t" + sim.population); int population = 0; // non-null elements in animals array int height, width; // size of the board int[][] food; // amount of food/energy, food[y][x] Animal[][] animals; // Animal at position [y][x], or null.
public void moveone() // Return if no animals if(population == 0) return; // Draw a random position that has an animal int y, x; do y = rand.nextint(height); x = rand.nextint(width); while(animals[y][x] == null); Animal anim = animals[y][x]; // Get local food context & choose move for animal int[][] fc = getfoodcontext(y, x); int dir = anim.choosemove(fc); // Check for death if(dir == Animal.DEATH) animals[y][x] = null; --population; return; // Find destination coordinates int nx = x, ny = y; if(dir == Animal.NORTH) ny = ywrap(y - 1); else if(dir == Animal.SOUTH) ny = ywrap(y + 1); else if(dir == Animal.WEST) nx = xwrap(x - 1); else if(dir == Animal.EAST) nx = xwrap(x + 1); // Move only if unoccupied destination square if(animals[ny][nx] == null) // Move the animal animals[ny][nx] = anim; animals[y][x] = null; // Feed the animal with energy from destination square anim.addenergy(food[ny][nx]); food[ny][nx] = 0; // If able to spawn, spawn new Rabbit at source position if(anim.spawnifpossible()) animals[y][x] = new Rabbit(0); ++population;