Un bon développeur est un développeur flemmard !

Il y a un petit moment, l'un de nos membres (twilightZone) a posté au sujet de ses solutions aux exercices proposé par Codility.

Donc premier retour d'expérience !

Présentation :
Codility propose des exercices de programmation sur un panel de langage...
Et il faut noter le nombre de langage disponible pour se faire évaluer !

Envoyé par Sélection des langages

C, C++, Java, Pascal, Python, C#, PHP, JavaScript, Perl, Ruby, VB.NET, Lua, Objective-C, Scala

A chaque fois on se retrouve avec une fonction prédéfinit à compléter avec quelquels commentaire util

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
// you can also use imports, for example:
// import java.util.*;
 
// you can use System.out.println for debugging purposes, e.g.
// System.out.println("this is a debug message");
 
class Solution {
    public int solution(int[] A) {
        // write your code in Java SE 8
    }
}

Il y a aussi une auto-complétion proposé (ctrl+espace sur window). Celle-ci ne vaux pas celle d'un IDE, mais elle est pertinente ! Du moins en Java...


Il est possible de compiler et tester votre fonction avec des cas de test, avant de valider l'ensemble. Le tout bien présenté et facile à comprendre.


La fonctionnalité à développer est décrite de manière assez détaillé au niveau algorithmique :

A zero-indexed array A consisting of N different integers is given. The array contains integers in the range [1..(N + 1)], which means that exactly one element is missing.

Your goal is to find that missing element.

Write a function:
class Solution { public int solution(int[] A); }
that, given a zero-indexed array A, returns the value of the missing element.

For example, given array A such that:
A[0] = 2
A[1] = 3
A[2] = 1
A[3] = 5
the function should return 4, as it is the missing element.

Assume that:
N is an integer within the range [0..100,000];
the elements of A are all distinct;
each element of array A is an integer within the range [1..(N + 1)].

Complexity:
expected worst-case time complexity is O(N);
expected worst-case space complexity is O(1), beyond input storage (not counting the storage required for input arguments).

Elements of input arrays can be modified.
Copyright 2009–2014 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

Faire l'excercie:

J'ai donc rapidement fait une implémentation correspondante :

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
import java.util.Arrays;
 
class Solution {
    public int solution(int[] A) {
        if(A.length == 0){
            //throw new RuntimeException("Array empty !");
            return 0;
        }
        Arrays.sort(A);
        for(int i= 0; i<A.length; i++){
            if(A[i]!= i+1){
                return i+1;
            }
        }
        //throw new RuntimeException("Missing Element Not Found !");
        return 0;
    }
}

Comme vous le constatez, j'ai commenté mes exceptions, car les tests ne s’attende pas à en avoir. Cependant, je ne savais pas quoi répondre...
Car le cas n'est pas précisé dans l'explication.
Voici le résultat :


J'avoue que j'ai été déçue par le résultat. 20%, c'est peu quand on ne gère juste pas les cas limites !

Pour ce billet, j'ai logiquement repassé le test en corrigeant l'implémentation pour correspondre aux test :

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
import java.util.Arrays;
 
class Solution {
    public int solution(int[] A) {
        if(A.length == 0){
            //throw new RuntimeException("Array empty !");
            return 1;
        }
        Arrays.sort(A);
        for(int i= 0; i<A.length; i++){
            if(A[i]!= i+1){
                return i+1;
            }
        }
        //throw new RuntimeException("Missing Element Not Found !");
        return A.length+1;
    }
}

Et on a le résultat "parfait" :


Il faut noter que le site propose bien plus que juste une évaluation du code !

Il vous propose une timeline avec le code écris par l'utilisateur, les tests correspondants et le résultat :



Conclusion :

Pour évaluer un développeur en n'étant pas en "live" ou en face à face, cela est probablement ce que j'ai vue de mieux pour le moment. Même si il est possible de repasser 40 fois l’examen, on se rend très vite compte grace à la timeline la différence entre une personne qui code et une personne qu place son copier/coller et valide !
Pour se challenger personnellement, c'est aussi sympathique, rapide et simple !

Rien que par curiosité, je vous conseil de faire le premier test dans votre langage préféré. Peut-être même le faire dans un langage moins maitrisé pour voir... Ou continuer sur les autres tests proposer.

Et vous qu'en pensez vous ?
Vous connaissez d'autres site sur le même principe ?

Cordialement,
Patrick Kolodziejczyk.

Source :
http://www.developpez.net/forums/d14...tion-codility/
http://pmantout.com/codility/
https://codility.com/programmers/
https://codility.com/demo/results/demoXZ8AQ4-UPM/
https://codility.com/demo/results/demo5CXS6Q-KQK/