22/08/2020: retrieved exercises from INGInious

Author: LucasMaris

MidTermQuiz/feedback_settings.yaml

@@ -0,0 +1,5 @@
+# Example of file
+exercise_type: default
+has_feedback: True
+quorum: 1.0
+feedback_kind: JavaGrading

MidTermQuiz/public/LEPL1402_MidTermQuiz.zip

@@ -0,0 +1,135 @@
+public class LinkedList {
+
+    private Node first;
+    private Node second;
+    private Node tail;
+    private int len;
+    private int nSwaps;
+    private int nPops;
+
+    private static class Node{
+
+        private int value;
+        private Node next;
+
+        private Node(int v, Node n){
+            this.value = v;
+            this.next = n;
+        }
+
+        private int getValue() {
+            return value;
+        }
+
+        private void setNext(Node next) {
+            this.next = next;
+        }
+    }
+
+    /**
+     * Create a new "linkedlist" with the content of the given array
+     * @param array
+     */
+    LinkedList(int[] array) {
+        nPops = 0;
+        nSwaps = 0;
+        len = 0;
+        for(int elem: array)
+            add(elem);
+    }
+
+    /**
+     * @return the first element of the list
+     */
+    public int getFirst() {
+        return first.value;
+    }
+
+    /**
+     * @return the second element of the list
+     */
+    public int getSecond() {
+        return second.value;
+    }
+
+    /**
+     * Swap the first and second element of the list
+     */
+    public void swap(){
+        Node oldFirst = this.first;
+        Node third= this.second.next;
+        this.first = this.second;
+        oldFirst.next = third;
+        this.first.next = oldFirst;
+        this.second = oldFirst;
+        nSwaps++;
+    }
+
+    /**
+     * Take the first element and put it at the end of the list
+     */
+    public void pop(){
+        Node oldFirst = this.first;
+        this.first=this.second;
+        this.second=this.first.next;
+        oldFirst.next=null;
+        this.tail.next = oldFirst;
+        this.tail = oldFirst;
+        nPops++;
+    }
+
+    /**
+     * Add an element to the list. You can make it public while debugging, if needed, but this will be private in
+     * INGInious.
+     * @param v element to add
+     */
+    private void add(int v){
+        if(len==0){
+            this.first = new Node(v, null);
+            this.len++;
+            this.tail = this.first;
+        }else if(len==1){
+            this.second = new Node(v, null);
+            this.first.setNext(this.second);
+            this.len++;
+            this.tail = this.second;
+        }else{
+            Node n = new Node(v, null);
+            this.tail.next = n;
+            this.tail = n;
+            this.len++;
+        }
+    }
+
+    /**
+     * @return True if the full list is sorted, False otherwise
+     */
+    boolean isSorted() {
+        Node current = this.first;
+        if(current==null) return true;
+        for(int i = 0 ; i < getSize()-1 && current.next!=null; i++){
+            if(current.getValue()>current.next.getValue()) return false;
+            current = current.next;
+        }
+        return true;
+    }
+
+    public int getSize() {
+        return len;
+    }
+
+    public String toString(){
+        String s = "[";
+        Node current = this.first;
+        while(current!=null){
+            s+= current.value + " ";
+            current = current.next;
+        }
+
+        s += " ]";
+        return s;
+    }
+
+    public int getnSwaps() { return nSwaps; }
+    public int getnPops() { return nPops; }
+}

MidTermQuiz/public/LinkedList.java

@@ -0,0 +1,31 @@
+public class Sorter {
+    /**
+    * Sorts a list in increasing order
+    *
+    * We expect this function to behave in O(n^2), where n is the size of the list. 
+    * Precisely, we expect that you make at MOST n^2 calls to list.pop() and at 
+    * MOST n^2 calls to list.swap(). 
+    * 
+    * You will obtain the full score for a test case if
+    *
+    * - The list is sorted (2/4 points per test case)
+    * - The list is sorted AND you make less than n^2 calls to swap (1/4 points)
+    * - The list is sorted AND you make less than n^2 calls to pop (1/4 points)
+    *
+    * @param list: a list of integers to be sorted.
+    */
+    public static void sort(LinkedList list) {
+        // Here is a small loop with an invariant that you should try to respect
+        // although it's not mandatory. Try to respect it, it will help you ;-)
+
+        for(int iter = 0; iter < list.getSize() - 1; iter++) {
+            //invariant: the 'iter' biggest elements are at the end of the list and are sorted.
+            //example, at iteration iter=3, the three lasts elements are the three biggest elements in the list, and
+            //they are in the increasing order.
+
+            // TODO
+        }
+
+        // here, if you followed the invariant proposed above, the list should be sorted!
+    }
+}

MidTermQuiz/public/Sorter.java

@@ -0,0 +1,36 @@
+#! /bin/inginious-ipython
+import importlib.util
+import sys
+
+
+thecode = get_input("studentCode")
+if "static" not in thecode:
+    with open('templates/Sorter.java', 'w') as f:
+        f.write("""
+package templates;
+import src.*;
+
+public class Sorter {
+    public static void sort(LinkedList list) {
+        @@studentCode@@
+    }
+}
+        """)
+
+# Dynamically load modules we need
+# Credits to https://stackoverflow.com/a/67692/6149867
+# And for the explanation : http://www.blog.pythonlibrary.org/2016/05/27/python-201-an-intro-to-importlib/
+def dynamically_load_module(module, path):
+    spec = importlib.util.spec_from_file_location(module, path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+#####################################
+# Our import for common run file    #
+#####################################
+sys.path.append("/course/common")
+
+runfile = dynamically_load_module("runfile", "/course/common/runfile.py")
+runfile.main()