Övning 1

Skriv en metod, factorial, som tar ett heltal, n, som argument och beräknar och returnerar fakulteten, n!.

Skriv sedan en main-metod som låter användaren ange ett positivt heltal, k, som programargument och skriver ut fakulteten för alla tal mellan 1 och k.

I main-metoden kommer du åt programargumenten via argumentet String[] args. Om man utgår från (vilket du kan göra i uppgiften) att användaren har gett ett argument så finns detta i args[0].

Du kan omvandla denna sträng till ett heltal genom att skriva Integer.parseInt(args[0]).

Skriv en metod, isPrime, som tar ett heltal och avgör om det är ett primtal. Metoden ska returnera true om det är ett primtal, annars false.

Skriv sedan ett program (en main-metod) som låter användaren ange ett heltal som programargument och skriver ut primtal eller ej primtal beroende på om det är det.

Skriv en metod som tar en array av 64-bitars flyttal, double, och returnerar det största av talen i arrayen. Arrayen kan antas ha minst ett element och ska ej förändras av metoden.

Skriv också en metod som tar en array av doubles och avgör om alla är lika, d.v.s. en boolesk metod. Även för denna metod kan arrayen antas ha minst ett element och den ska ej förändras.

Skriv sedan en main-metod som låter användaren ange flera flyttal som programargument (separerade med mellanrum). Om alla talen är lika ska programmet skriva att så är fallet. I annat fall ska det skriva ut det största av dem. Programmet kan förutsätta att programargumenten bara innehåller välformaterade flyttal.

Argumenten finns på var sin plats i args – args[0], args[1] o.s.v.

Man kan parsa (omvandla från sträng) flyttal med Double.parseDouble.

Skriv en metod som tar en array av heltal och kastar om ordningen på dem (alltså motsvarande Haskells reverse för listor). Metoden ska inte förändra arrayen utan skapa en ny array där resultatet finns och returnera denna.

Skriv ett program som utgår från att det anges ett programargument och att detta argument är namnet på en fil. Programmet ska utgå från att filen finns, att det är en textfil och att den innehåller en lista med heltal separerade med komma-tecken.

1,2,2,5,4,6,8

Programmet ska avgöra om talen utgör en växande (alla tal är minst lika stora som föregående) sekvens och skriva ut antingen

sekvensen är växande om så är fallet

eller

t.ex. 4 är mindre än 5 annars.

Man kan läsa in en fil på liknande sätt som med funktionen readFile i Haskell på följande sätt:

String str = new String(java.nio.file.Files.readAllBytes(java.nio.file.Paths.get(filnamn)));

där filnamn är en String som innehåller filnamnet. Använder man raden ovan så klagar kompilatorn. Det räcker här att fixa det genom att lägga till throws Expception i signaturen till main-metoden.

Man kan dela upp en sträng med hjälp av reguljära uttryck:

str.split(",") ger en array av strängar, en för varje del som separeras av ett komma-tecken.

Betrakta följande program:

public class A {

  public static void f(int i, int j, int[] a) {
     int tmp = a[i];
     a[i] = a[j];
     a[j] = tmp;
  }

  public static void main(String[] args) {
     int[] a = {3, 7, 9};
     f(0,2,a);
     for (int i=0; i < a.length; i++)
       System.out.print(a[i] + " ");
     System.out.println();
  }
}

Vad skriver programmet ut? Förklara kortfattat vad som händer.

Skriv en metod fibonacci som beräknar Fibonacci-talet för ett positivt heltal. Fibonacci-talen, f_k, definieras rekursivt genom följande ekvationer:

f₁ = 1

f₂ = 1

f_k = f_k − 1 + f_k − 2 för k > 2