2TX Wiskunde 3

Uit Diana's examenwiki

Januari 2017

STATISTIEK (vak hervormd)

3 Grote vragen:

1) oefening met kansberekening.

2) oefening met hypothesetoets. (H6)

3) oefening met samenhang tussen variabelen. (H7)



Januari 2016

Deel 1: Algoritmitiek (Phillipaerts)

1a) Benoem volgende bomen (binaire zoekboom, complete binaire boom, binaire min-heap, binaire max-heap)

1b) Geef alle interne nodes van eerste boom

1c) Geef alle ? van tweede boom (Vergeten wat het was)

1d) Geef de volgorde wanneer boom C als array

1e) Geef de volgorde van afprinten adv de post-order

2a) wat doet volgende code :

   public static void mysteryR(int count){
   LinkedList<String> ll = new LinkedList<String>();
   ll.addLast("0");
   ll.addLast("1");
   while (ll.size() > 0){
      String r = ll.removeFirst();
      if (r.length() == count){
         System.out.println(r);
      }else{
         ll.addLast(r + "0");
         ll.addLast(r + "1");
      }
    }
   }


2b) Schrijf de recursieve vorm van voorgaande functie. Je mag hulpmethodes gebruiken maar enkel lokale variabelen; geen klassevariabelen dus.

     public static void mysteryR2(int count) {
     mysteryR2(count, "0", "1");
     }
     public static void mysteryR2(int count, String r1, String r2){
          if(r1.length() == count){
              System.out.println(r1);
              System.out.println(r2);
          }else{
              mysteryR2(count, r1 + "0", r1 + "1");
              mysteryR2(count, r2 + "0", r2 + "1");
          }
     }

Leuk voor de oplossing maar dit is beter

     public static void mysteryRecuvie(int count){
           mystery(Math.abs(count),"");
     }
     private static void mystery(int count, String str){
     	if(str.length() == count)
     		System.out.println(str);
     else
     	{
     		mystery(count, str + "0");
     		mystery(count, str + "1");
     	}
     }

3a) Een of andere prof bewees in 1950 dat elke graaf van grote n waarbij elke knoop minstens n verbindingen had automatisch een hamiltoniaans pad heeft. Gegeven:

     public boolean isZoEenSoortGraaf(boolean[][] graph){
     	for(.........................................)
     		int degree = 0;
     		for(.............................................)
     		        if(.........................)
     				degree++;
     		if(......)
     			return false;
     	return true;
     }

vervolledig bovenstaande code

3b) Wat kan je doen om bij bovenstaande code minder iteraties te hebben? Je hoeft geen code te schrijven maar wel uit te leggen.


Deel 2: Statistiek

1) Gegeven een gemiddelde en een variantie.

1a) Geef een 90%-betrouwbaarheidsinterval.

2b) onder welk getal vallen de 8% kleinste gegevens.

3b) vergeten

4b) vergeten


2) Gegeven een tabel met processoren, hun klokfrequentie en hun ranking

2a) Is er een aannemelijk lineair verband?

2b) Indien wel; geef de correlatie weer

3b) Wat gebeurt er in het geval van een uitschieter? Wat geeft dit voor onze tabel?

4b) Welke problemen zie je opduiken in deze tabel? Wat kan er beter?

Augustus 2015

Deel 1 : Statistiek (Wim Bertels)

1a) In een doos zitten er 10 cd'r. Wat is de kans dat alle 10 voorbij 1000 uren gaan als je weet dat de gemiddelde levensduur 1200 is en variantie = 10000.

  STAND.NORM.VERD((1000-1200)/100)) = 0.02275
  => P(Z>1000) = 1-0.02275 = 0.97725
  => P(alle 10) = 0.97725^10 = 0.7944

1b) Stel dat de gemiddelde levensduur niet gegeven is. Wat is de gemiddelde levensduur van een cd'r als je weet dat 7% van de cd'r kapot gaan voor 1000 uren?

  (1000-µ)/100 = STAND.NORM.INV(0.07)
  => (1000-µ)/100 = -1.47579
  => µ = 1147.579

2) Vraag over lineairverband/regressierechte

Deel 2 : Ausseloos

1) Recursieve preorder schrijven voor een CompleteIntTree (nodes worden in een array gestoken).

  public class CompleteIntTree{
       private int[] array;
       private int size;
       public CompleteIntTree(int capacity){
            array = new int[capacity];
            size = 0;
       }
       // Andere methoden die garanderen dat de boom compleet blijft.
       public void printPreorder(){
            printPreorder(0);
       }
       public void printPreorder(int index){
            if(index>=size) return;
            System.out.print(array[index]);
            printPreorder(2*index+1);
            printPreorder(2*index+2);
       }
 }

2) Schrijf een iteratieve getMaxDepth() methode. ZOEK DE FOUT:

 public int getMaxDepth(){
   Queue<BinaryNode<E>> queue = new LinkedList<BinaryNode<E>>();
   queue.add(root);
   int diepte = 0;
   while(!queue.isEmpty()){
       diepte++;
       for(int i=0; i<queue.size(); i++){
            BinaryNode<E> node = queue.poll();
            if(node.left!=null) queue.add(node.left);
            if(node.right!=null) queue.add(node.right());
       }
   }return diepte;
 }

JUIST:

 public int getMaxDepthItt(){
   Queue<BinaryNode> queue = new LinkedList<>();
   queue.add(root);
   BinaryNode node;
   int depth=0;
   while(!queue.isEmpty()){
     depth++;
     int nodes = queue.size();
     for(int i=0;i<nodes;i++){
       node = queue.poll();
       if(node.left !=null)queue.add(node.left);
       if(node.right !=null)queue.add(node.right);
     }
   }
   return depth;
 }

3) Schrijf een recursieve countBetween(double a, double b) methode in een BST.

Januari 2015

Deel 1 : Statistiek (Wim Bertels)

1) Arne en Bob gaan soms samen naar school, de kans dat Arne te laat is, is 0,25. De kans dat Bob te laat is, is 0,20. De kans dat Arne te laat is als Bob te laat is, is 0,70.

a) Kans dat ze beiden te laat zijn.

b) Kans dat alleen Arne te laat is.

c) Kans dat ze beiden OP TIJD zijn.

d) Wat is de kans dat bij zeven willekeurige dagen, Arne net één dag te laat is.

2) Wat houdt een Pearsoncoëfficient van -1 juist in? Omschrijf dit duidelijk.

3) een winkel houdt statistieken bij van de winkelwagens. Er is een ongekend gemiddelde en een standaardafwijking van 64 €. je hebt 12 winkelwagens en een berekend gemiddelde van 81. (de exacte getallen van de opgave weet ik niet meer.)

a) je moet een 94% betrouwbaarheidsinterval berekenen hiervoor.

b) wat zegt dit interval over je winkelwagens?

c) Bereken de betrouwbaarheid bij een breedte van 50 euro. --

Deel 2 : Mario Ausseloos

1) Schrijf de recursieve functie voor countPos() in een BST. Bedoeling is een recursieve functie te schrijven die telt hoeveel positieve getallen er in deze BST zijn.

2) Schrijf de iteratieve functie lookup(E target) in een pointer implementatie van een BST.

3) Gegeven code: HamiltonianCycleBacktracking, vul 4 lijnen code aan.

Januari 2014

Deel 1 Statistiek (Wim Bertels)

De eerste vraag varieerde licht tussen verschillende versies van het examen.

1. Men verkoopt meiklokjes waarvan 9/10 uitkomen, 1/10 niet. De bollen worden willekeurig verpakt in dozen van 10 verpakt en de firma garandeert dat er in elke doos minstens 9 bollen zitten die uitkomen.

A) Hoe groot is de kans dat je een doos koopt waarin er 2 of meerdere bollen zitten die niet uitkomen? (Dus: hoe groot is de kans dat aan de eigenschap niet wordt voldaan) (Zie oefening 13 pag 72)

X = aantal bollen dat niet uitkomt

p = 0.1

q = 0.9

n = 10

Binomiale verdeling opstellen en uitrekenen P(X>=2)= 26.39%

B) Een winkelier koopt bij de groothandelaar 100 dozen van deze bollen. Wat is de kans dat precies 3 van deze dozen de gegarandeerde eigenschap niet hebben?

X = aantal dozen die niet voldoen aan de eigenschap

p = 0.2639

q = 0.7361

n = 100

P(X=3) = 3.6804 * 10^-10

2. Vraag over criminaliteitsratio's. Er moesten betrouwbaarheidsintervallen worden berekend waar 99% en 99.5% van de gevallen binnen lagen. Gegeven was een tabel met ratio's van 18 steden en de populatievariantie. Daarna volgde er nog 2 kleine theorievragen (in de aard van: waarom een steekproef onbetrouwbaar is en hoe men de variantie kan berekenen.) Daarna volgde er nog een vraag met juist/fout opgaves (geen verklaring nodig, het juiste moest omcirkeld worden.)

Deel 2 Mario Ausseloos

1. Een boom werd gegeven en moest doorlopen worden via postorder, we moesten de volgorde opschrijven. Er moest aangeduid kunnen worden of die boom een binaire boom was (of niet), met verklaring. Tot slot moest er ook nog aangeduid worden of die boom een AVL boom was (of niet), met verklaring erbij.

Post-order = Eerst linker sub-boom doorlopen, dan rechter sub-boom doorlopen, dan waarde printen.

Binaire boom = Max. 2 kinderen per node, linkerkind heeft altijd een kleinere waarde, rechterkind altijd een grotere

AVL boom = Binaire boom waarbij het verschil in diepte voor elke node niet groter is dan 1

2. Recursieve methode om in een binaire boom het maximum te vinden (getMax())

  public int getMax()
  {
     if(root == null) return Integer.MIN_VALUE;
     return getMax(root);
  }
  private int getMax(BinaryNode node)
  {
     if(node.getRight() == null) return node.getData();
     return getMax(node.getRight());
  }

3. Iteratieve methode om in een Binary Min Heap het maximum te vinden. De array van de min heap mocht niet volledig worden overlopen.

Opgelet: De laatste waarde van een Binaire Min Heap is niet altijd de grootste waarde! Oplossing is enkel de 2e helft van de boom na te kijken, aangezien nodes in de 1e helft van de boom kinderen hebben en dus nooit de max. kunnen zijn.

   public E getMax() {
   		
       if(size == 0) return null;
   		
       int max = 0;
       // We checken enkel de 2e helft van de boom
       // Nodes in de 1e helft van de boom hebben kinderen en kunnen dus
       //  onmogelijk de max. zijn.
       for(int i = (int) Math.ceil(size / 2); i < size; i++) {
           if(heap[i].compareTo(heap[max]) > 0) {
               max = i;
           }
       }
   		
   	return heap[max];
   }

4. Schrijf de isValid()-methode voor HamiltonionCycleFinderBruteforce

   private boolean isValid(boolean[][] graph, int[] cycle){
   	
   	int[] sortedCycle = cycle.clone();
   	Arrays.sort(sortedCycle);
   	
   	for(int j = 0; j < cycle.length - 1; j++){
   		if(sortedCycle[j] == sortedCycle[j+1]){
   			return false;
   		}
   	}
   	
   	for(int i = 0; i < cycle.length-1; i++){
   		if(!graph[cycle[i]][cycle[i+1]]){
   			return false;
   		}
   	}
   	
   	if(!graph[cycle[cycle.length-1]][cycle[0]]){
   		return false;
   	}
   	
   	return true;
   }

5. Gegevens was wat code, controleer of de code werkt en zoja, leg uit waarom, en zonee, verklaar waar de bugs zich bevindt. (Was de printCodes()-methode van HuffmanTree.)

Correcte versie:

   private void printCodes(HuffmanTreeNode node, ArrayList<Integer> code) {
   
   	if(node.left == null && node.right == null) {
   		System.out.println(Arrays.toString(code));
   		return;
   	}
   	
   	if(node.left != null) {
   		code.add(0);
   		printCodes(node.left, code);
   		code.remove(new Integer(0));
   	}
   	
   	if(node.right != null) {
   		code.add(1);
   		printCodes(node.right, code);
   		code.remove(new Integer(1));
   	}
   }

We gebruiker new Integer(...) bij het verwijderen van de code omdat we het Integer object 0 of 1 willen verwijderen, niet de index.