Tentamen i Programmering

Transkript

1 LUNDS TEKNISKA HÖGSKOLA 1(5) Institutionen för datavetenskap Tentamen i Programmering EDAA65/EDA501/EDAA20 M MD W BK L , Preliminärt ger uppgifterna = 40 poäng. För godkänt betyg krävs 20 poäng. Tentan innehåller fem frågor. Läs igenom hela innan du sätter igång. Kommentarer från specifikationerna (/**... */) behöver inte skrivas i lösningen. Svara enbart på lösblad och numrera de blad ni lämnar in, själva tentan ska inte lämnas in Tillåtet hjälpmedel: Java-snabbreferens. Lösningsförslag kommer att finnas på kursens hemsida senast dagen efter tentamen. Resultatet läggs in i Ladok när rättningen är klar och anslås inte på anslagstavlan. Tentamensvillkor: Om du tenterar utan att vara tentamensberättigad annulleras din skrivning. För att undvika att någon skrivning annulleras av misstag kommer alla som, enligt institutionens noteringar, tenterat utan att vara tentamensberättigade att kontaktas via epost. Felaktigheter i institutionens noteringar kan därefter påtalas fram till nästa tentamenstillfälle då resterande skrivningar annulleras. Bakgrund: polynom Från matematiken känner vi begreppet polynom. Beräkningar med polynom förekommer i många viktiga tillämpningar, som exempelvis datorkommunikation och kryptering. Några exempel på polynom är p 1 = 3x 3 2x 2 + 5x + 4 p 2 = 2x 2 p 3 = 4x 9 Mer generellt är ett polynom en summa av termer, där varje term har formen ax b Där kallar vi a för termens koefficient och b för dess exponent. I ett polynom är alla exponenter heltal och icke-negativa (b 0). Vi begränsar oss här vidare till polynom i en variabel (x) och heltalskoefficienter. De tre polynomen p 1, p 2 och p 3 ovan är exempel på just sådana polynom.

2 2(5) 1. Vi börjar med klassen Term, som beskriver en term i ett polynom enligt ovan. En sådan term har en koefficent och en exponent, båda heltal. Klassen Term har följande specifikation: /** Skapar en polynomterm med koefficienten a och exponenten b. Koefficienten a antas vara skild från noll, och exponenten b antas vara större än eller lika med noll. */ Term(int a, int b); /** Hämtar termens koefficient. */ int coeff(); /** Sätter termens koefficient till a. Parametern antas vara skild från noll. */ void setcoeff(int a); /** Hämtar termens exponent. */ int exp(); /** Beräknar produkten av denna term och termen other. Produkten returneras som en ny term. Inget av de båda faktorernas Term-objekt förändras. */ Term times(term other); /** Returnerar en strängbeskrivning av termen, exempelvis "5x2" (se anvisningar). */ String tostring(); >>> Uppgift: implementera klassen Term. När man multiplicerar två polynomtermer så multiplicerar man koeffienterna och adderar exponenterna: a 1 x b 1 a 2 x b 2 = (a 1 a 2 )x (b 1+b 2 ) Metoden tostring returnerar en strängbeskrivning av termen, exempelvis 5x2 för polynomtermen 5x 2. Strängens form, med exempel i den högraste kolumnen, beror på exponentens värde: exponent strängens innehåll exempel > 1 koefficient, bokstaven x samt exponent 3x 7 uttrycks 3x7 = 1 koefficient samt bokstaven x 3x 1 = 3x uttrycks 3x = 0 endast koefficient 3x 0 = 3 uttrycks 3 Koefficienten ingår alltid, även om den är 1. Polynomtermen x 5 = 1x 5 uttrycks alltså 1x5. Exempel: följande satser skapar objekt motsvarande polynomtermerna 3x 3 och 9x 4 samt dessas produkt, 27x 7. Term t1 = new Term(3, 3); Term t2 = new Term(9, 4); Term t3 = t1.times(t2); System.out.println(t1.toString()); System.out.println(t2.toString()); System.out.println(t3.toString()); 3x3 9x4 27x7

3 3(5) 2. Nu ska vi gå vidare med polynom, som alltså består av ett antal termer. Varje term beskrivs av ett Term-objekt enligt föregående uppgift. Ett polynom innehåller högst en term med en given exponent. Av effektivitetsskäl ska endast termer med koefficient skild från 0 (noll) lagras. >>> Uppgift: implementera klassen Polynomial: /** Skapar ett tomt polynom (utan några termer). */ Polynomial(); /** Metoden adderar termen t till polynomet. Om det redan finns en term med samma exponent läggs ingen ny term till; istället adderas koefficienten till den befintliga termens koefficient. Om den koefficienten då blir noll så tas termen bort ur polynomet. */ void add(term t); /** Hämtar en strängbeskrivning av polynomet, exempelvis 3x2+2x-1. Strängen innehåller alla termer ordnade efter exponentens värde, med högst exponent först. Alla termer, utom den första, föregås av ett plustecken om termen är positiv (dvs dess koefficient är > 0). För ett tomt polynom returneras "0".*/ String tostring(); Använd en lista (ArrayList) av termer. Din lösning ska inte använda någon av Javas standardklasser för sortering, som t. ex. sortmetoderna i Collections, Arrays eller List. I tostring ska inget plustecken föregå negativa termer, eftersom tostring-resultatet från Term redan innehåller minustecken för sådana termer. Exempel: följande satser skapar polynomet 3x 2 4, beräknat som 5x 4 + 4x 2 5x x 2. Notera: Ordningen i utskriften skiljer sig från add-anropens ordning. De två x 2 -termerna har summerats till en enda (4x 2 x 2 = 3x 2 ). De två x-termerna har tagit ut varandra (5x 5x = 0). Därför saknar polynomet x-term. Polynomial poly = new Polynomial(); poly.add(new Term(5, 1)); // 5x poly.add(new Term(-4, 0)); // -4 poly.add(new Term(4, 2)); // 4x2 poly.add(new Term(-5, 1)); // -5x poly.add(new Term(-1, 2)); // -1x2 System.out.println(poly.toString()); 3x2-4

4 4(5) 3. En viktig operation i dessa sammanhang är multiplikation av polynom. Principen är den vi själva använder när vi multiplicerar parenteser i matematiken: vi multiplicerar, i tur och ordning, varje term i det ena polynomet med varje term i det andra. Ett exempel utan dator illustrerar principen. Låt p 1 och p 2 vara som följer: p 1 = 4x + 3 p 2 = 3x 2 + 2x + 1 Polynomet p 1 har två termer, och p 2 har tre. Vi multiplicerar varje term i p 1 med varje term i p 2, och får därför 2 3 = 6 delprodukter. Resultatet är summan av dessa delprodukter: p 1 p 2 = (4x + 3) (3x 2 + 2x + 1) = 4x 3x 2 + 4x 2x + 4x x x = 12x x x + 3 >>> Uppgift: implementera metoden times i klassen Polynomial: /** Beräknar produkten av detta polynom och polynomet other. Produkten returneras som ett nytt polynom. Inget av de båda faktorernas Polynomial-objekt förändras. */ Polynomial times(polynomial other); resten av klassen (förutom metoden times) behöver inte återges i lösningen. Exempel: i följande programexempel används metoden times för samma beräkning som ovan: Polynomial p1 = new Polynomial(); p1.add(new Term(4, 1)); // 4x p1.add(new Term(3, 0)); // 3 Polynomial p2 = new Polynomial(); p2.add(new Term(3, 2)); // 3x2 p2.add(new Term(2, 1)); // 2x p2.add(new Term(1, 0)); // 1 Polynomial product = p1.times(p2); System.out.println(product.toString()); 12x3+17x2+10x+3 4. Vi vill nu ha ett program för att använda polynomoperationerna. Programmet ska läsa in två polynom från tangentbordet och skriva ut deras produkt. Varje polynom matas in som en serie av heltal: först polynomets grad (dvs högsta exponent), därefter koefficienten för termen med högst exponent, koefficienten för näst högst exponent, och så vidare. Konstanttermen anges sist. Ett polynom av grad n skrivs här alltid med n + 1 koefficienter. Exempel. De två polynomen 7x 3 1 och 2x + 5 matas in så här: 3 grad x 3 +0x 2 +0x 1 1 grad 2 5 2x+5 Förväntat resultat [eftersom (7x 3 1) (2x + 5) = 14x x 3 2x 5]: 14x4+35x3-2x-5 >>> Uppgift: skriv ett program (klass med main-metod) som läser in två polynom och skriver ut deras produkt, enligt ovan. Ingen felhantering krävs, du får utgå från att indata matas in korrekt. Endast termer med koefficient skild från noll ska adderas till polynomen.

5 5(5) 5. Programmen nedan skriver ut ett tal när de körs. Båda programmen går alltså att kompilera och köra. >>> Uppgift: ange, för deluppgift (a) (b), vilket tal som skrivs ut när respektive program körs. Ingen motivering behövs. Poäng ges endast för korrekt svar. (a) public class Bugaboo { public static void main(string[] args) { int x = 2; while (x > 1) { if (x == 7) { x = 0; x++; System.out.println(x); (b) public class Primes { public static int findnumber(int[] v, int nbr) { for (int i = 0; i < v.length; i++) { if (v[i] == nbr) { return i; else { return -1; return -1; public static void main(string[] args) { int[] z = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53 ; int k = findnumber(z, 13); System.out.println(k);