Pentru ca vrem sa te intalnim si sa stam de vorba cu tine, participam si anul acesta la Angajatori de Top (28-29 Octombrie 2011) la Sala Palatului din Bucuresti. Anuntam venirea noastra prin cateva stickere colorate afisate in metrou pe linia albastra (Pipera – IMGB).

Daca se intampla sa le vezi :

… fa o poza cu tine/prietenii tai langa ele

… uploadeaza poza pe pagina noastra de Facebook

… primeste cele mai multe like-uri (pana pe 26 Octombrie cand inchidem concursul) si castiga un premiu din partea noastra: un tricou cu Mo si Foca si o licenta Creative Suite CS 5 (la alegere intre Design sau Web).

Te asteptam sa il ridici de la standul Adobe in cadrul evenimentului (daca esti din Bucuresti) sau ti-l trimitem noi prin posta.

Ti-ai pregatit aparatul foto?

Se dă un graf orientat aciclic cu N noduri și M arce.
Fie K numărul de drumuri distincte de la nodul 1 la nodul N. Se cere restul obținut prin împărțirea lui K la 2011.

Programul primește datele de intrare din fișierul “drumuri.in”, ce conține pe prima linie numerele N si M, iar pe urmatoarele M linii câte două numere separate prin spațiu, “x y”, reprezentând câte un arc din graf (de la nodul x la nodul y). În fișierul “drumuri.out” trebuie afișat numărul cerut – restul obținut prin împărțirea numărului de drumuri la 2011.

Restricții și precizări:

• 2<=N<=1.000.000.
• 1<=M<=1.000.000.
• Între două noduri pot exista mai multe arce.

Exemplul 1:

Fișier de intrare: drumuri.in:

4 5
1 2
1 3
3 2
3 2
2 4

Fișier de iesire: drumuri.out:

3

Explicație: sunt 3 drumuri: 1->3->2->4, 1->3->2->4 (exista 2 arce 3->2), 1->2->4.

Exemplul 2:

Fișier de intrare: drumuri.in:

3 2
1 2
3 1

Fișier de ieșire: drumuri.out:

0

Explicație: nu există nici un drum de la nodul 1 la nodul 3 (graful este orientat).

Barem:

• 3p – descrierea în README.txt a algoritmului, complexitate, de ce functionează – se acordă maximul doar dacă complexitatea este cea optimă;
• 2p – funcționarea pe exemple precum cele din enunț;
• 5p – Cod funcțional de complexitate optimă;
  • +/- 1p Coding style;
  • -2p Complexitate neoptimă;
  • -4p Complexitate total neoptimă;
• Punctajul este intre 0-10.

Update:

• Mai intâi sortăm topologic nodurile grafului.
• În continuare construim pas cu pas numarul de drumuri de la nodul 1 până la fiecare nod care se află după el, în urma sortării topologice:
  • Dacă nodul N este inaintea nodului 1, atunci rezultatul este 0.
  • De la nodul 1 până la el insuși există un singur drum (drumul fără niciun arc).
  • De la nodul 1 până la următorul (conform ordinii date de sortare) există un număr de drumuri egal cu numărul de arce dintre cele doua noduri.
  • Pentru un nod oarecare X, având calculate numerele de drumuri de la nodul 1 până la nodurile precedente lui X, fiecare arc de forma (Y, X) care intră în X, adaugă D drumuri, unde D este numărul de drumuri până la Y (fiecare D este cunoscut, pentru că orice nod Y pentru care există arc (Y, X) este înaintea lui X dupa sortarea topologică).
• În momentul în care s-a calculat numărul de drumuri pentru nodul N, se poate afișa valoarea cerută. Întrucât numărul de drumuri până la un nod poate fi foarte mare, numerele intermediare din cadrul soluției sunt considerate modulo 2011.

Complexitate: O(N+M) (atât sortarea topologică, cât și a doua parte au aceeași complexitate).

Am pornit prima rundă de testare, iar problemele sunt acum pe blog.

Pentru DEV-i:

• Avem 5 probleme, textul si baremele le găsești aici:
  • Problema 1
  • Problema 2
  • Problema 3
  • Problema 4
  • Problema 5
• Timpul de rezolvare si submitare a temelor este de 24 de ore.

Pentru QE-i:

• Avem 2 probleme, textul si baremele le găsești aici
• Timpul de rezolvare si submitare a temelor este de 24 de ore.

Pentru UX-i:

• Avem 2 probleme, textul si baremele le găsești aici
• Timpul de rezolvare si submitare a temelor este de 72 de ore.

Ce urmează să se întâmple?

• În decursul zilelor următoare vom răspunde la toate întrebările trimise pe forum, în cel mai scurt timp;
• Duminică vom posta soluțiile problemelor pentru DEV-i, împreună cu explicațiile rezolvărilor;
• Ne trimiți rezolvarea prin mail la educatie@adobe.com sau hr-romania@adobe.com, sau  prin www.transfer.ro;
• În două săptămâni vom posta rezultatele, deci urmărește-ne blogul ca să știi dacă ai fost selecționat;
• Dacă nu ai timp să participi la runda unu, așteaptă runda a doua de pe 29 mai și mai exersează între timp.

Urmărește-ne blogul ca să fii la curent!

Programul primește la intrare un fișier ce conține:

• pe prima linie n, numărul de elemente din A
• pe a doua linie m, numărul de elemente din B
• pe fiecare din următoarele m linii câte două numere din {1,2,..,n} separate printr-un spațiu care reprezintă cele m perechi ale lui B.

La ieșire, programul afișează pe consolă caracterul “A” dacă există o permutare ca în enunț sau caracterul “F”, în caz contrar.

Exemplul 1:

Fișierul de intrare data.in conține:

4
5
1 2
2 3
3 4
1 3
4 1

Date ieșire (pe consolă):

A

Exemplul 2:
Fișierul de intrare data.in conține:

4
6
1 2
2 3
3 4
1 3
4 1
4 2

Date ieșire (pe consolă):

F

Barem:

• 3p – descrierea în README.txt a algoritmului, complexitate, de ce functionează – se acordă maximul doar dacă complexitatea este cea optimă;
• 2p – funcționarea pe exemple precum cele din enunț;
• 5p – Cod funcțional de complexitate optimă;
  • +/- 1p Coding style;
  • -2p Complexitate neoptimă;
  • -4p Complexitate total neoptimă;
• Punctajul este intre 0-10.

Soluție:
Algoritm:

Se consideră graful orientat G=(A,B) cu vârfurile elementele lui A și muchii elementele lui B (pentru fiecare pereche (x,y) din B considerăm că avem muchia x–y). Condițiile impuse asupra lui B spun că graful este neorientat și că este conex. Problema se transformă în a determina dacă în G avem o cale x₁->x₂->…->x_m->y_m care trece prin toate muchiile grafului exact o data. Avem de determinat dacă G conține ceea ce se numește o cale euleriana (cale care trece prin toate muchiile grafului).

Pentru un graf care conține o astfel de cale avem următoarele proprietăți:

• orice nod X care nu este cel de plecare sau de sosire avem in(X) = out(X) pentru că altfel calea fie s-ar opri în X dacă in(X)>out(X) sau nu ar conține unele muchii care pleacă din X dacă in(X) < out(X). Altfel spus, de fiecare dată când calea intăa pe o muchie în nodul X, iese pe o alta muchie.
• daca punctul de start (S) nu este cel de terminare (T) a căii, atunci: out(S) – in(S) = 1 si out(T) – in(T) = -1. Aceasta trebuie să fie adevărat deorece în afară de muchia de start care pleaca din S, de fiecare dată ulterioara când calea ne duce în S, vom pleca din S pe altă muchie. Analog pentru T.
• daca S=T, atunci vom avea ca și pentru celelalte noduri in(S) = out(S), ca mai sus. (în acest caz avem un circuit eulerian)

Argumentarea că condițiile de mai sus sunt și suficiente. Dacă pentru un nod oarecare X notăm F(X) = out(X) – in(X), aceasta ar însemna:

• daca S<>T, avem F(X)=0, pentru X<>S si X<>T, F(S)=1 si F(T)=-1
• dacă S=T, F(X)=0 pentru orice nod.

Pentru a demonstra afirmația aceasta vom arăta cum construim o astfel de cale in graful conex G. Dacă ne aflăm în primul caz (cu S<>T) în care avem F(S)=1 și F(T)=-1 procedăm astfel. Pornim din S și luăm unul din vecinii lui X1, încercând, dacă se poate, să evitam nodul T. Stergem muchia S->X1. Cum F(X1)=0, rezultă că avem și o muchie mai departe, care iese din X1 (la fel, încercăm să evitam nodul T, dacă se poate) Fie aceasta X1->X2. Ștergem și această muchie. La fel, cum inițial F(X2)=0, trebuie să avem o muchie să ieșim din nodul X2. Se repetă procedeul, iar la un moment ajungem în nodul X_i. Chiar dacă s-a mai trecut prin acest nod, prin ștergerea muchilor de intrare și ieșire, am micșorat atât in-ul cât și out-ul său cu aceeași valoare. Deci înainte de ștergerea muchiei care ne-a dus la el tot avem F(X_i)=0 (și pentru graful cu muchiile șterse). De aceea, rezultă că avem și muchie de ieșire. Repetăm procedeul până când rămânem într-un nod. Acesta trebuie să fie T ca mai sus. Analog pentru cazul S=T (se pornește cu orice nod din graf).

Implementare Java în O(m) (unde m este numărul de muchii)

public class Pair {
   //auxiliary class describing an edge
   public Integer first;
   public Integer second;
   public Pair(Integer first, Integer second) {
     this.first = first;
     this.second = second;
   }
 }

 public static boolean hasEulerianPath(int n, List<Pair> b) {
   Integer[] F = new Integer[n + 1];
   //compute for each node F[i] = out(i) - in(i)
   for (Pair p: b) {
     F[p.first]++;
     F[p.second]--;
   }
   int start = 0;
   int end = 0;
   for (int i = 1; i <= n; i++) {
     switch (F[i]) {
       case 0:
         break;
       case 1:
         if (start == 0) {
           start = i;
         } else {
           return false; // we have at least 2 nodes with F[i] = 1
         }
         break;
       case -1:
         if (end == 0) {
           end = i;
         }
         else {
            return false; // we have at least 2 nodes with F[i] = -1
         }
       default:
         return false;
     }
   }
   return true;
 }

Utilizând datele din fișierul de intrare, stabiliți dimensiunea grupului de mincinoși și a celui de oameni care spun adevarul. Dacă aceasta nu este posibil, afișați acest fapt.

Programul primește 2 parametri de intrare: numele fișierului de input și numele fișierului de output.

Fișierul de intrare are structura:

• număr_persoane_care_au_răspuns
• numele_persoana_1_care_răspunde număr_mincinoși_raportați_1
• numele_mincinos 1_1
• numele_mincinos 1_2
• …
• numele_persoana_2_care_răspunde număr_mincinoși_raportați_2
• numele_mincinos_2_1
• numele_mincinos_2_2
• …
• numele_persoana_n_care_răspunde număr_mincinoși_raportați_n
• …

Fișierul de ieșire conține 2 numere:

• mărimea_celui_mai_mare_grup mărimea_grupului_mai_mic în cazul în care avem soluție
• sau -1 pe prima linie dacă nu exista soluție.

Exemplul 1
Fișierul de intrare in.data out.data conține:

5
A 1
B
B 1
C
D 1
B
C 1
B
E 2
D
A

Explicație: 5 persoane au răspuns:

• A spune că B e mincinos;
• B spune că C e mincinos;
• D că B e mincinos;
• C că B minte și
• E că D și A mint.

out.data conține:

3 2

Exemplul 2
Fișierul de intrare in.data conține:

2
A 1
B
C 2
B
A

Explicație: 2 persoane au raspuns:

• A , care spune ca B minte;
• C, care spune ca atat B, cat si A sunt mincinosi.

out.data conține:

-1

Barem:

• 3p – descrierea în README.txt a algoritmului, complexitate, de ce functionează – se acordă maximul doar dacă complexitatea este cea optimă;
• 2p – funcționarea pe exemple precum cele din enunț;
• 5p – Cod funcțional de complexitate optimă;
  • +/- 1p Coding style;
  • -2p Complexitate neoptimă;
  • -4p Complexitate total neoptimă;
• Punctajul este intre 0-10.

Soluție

Algoritm:

1. Se construiește un graf în care fiecare nod este un om și un arc de la x->y inseamnă că X a spus că Y minte.
2. Se folosește BFS pt a “colora” toate nodurile în 2 culori.
3. Daca s-a reușit colorarea înseamnă că avem un graf bipartit și putem împărți oamenii în 2 mulțimi ( bazate pe culoare).

Implementare java:

public void solve(HashMap<String, HashSet<String>> liars, HashSet<String> knownPeople) {

        ArrayList<String> whiteListPeople = new ArrayList<String>();
        ArrayList<String> queue = new ArrayList<String>();
        HashMap<String, Integer> color = new HashMap<String, Integer>();
        for (String person : knownPeople)
            whiteListPeople.add(person);

        String person = whiteListPeople.get(0);
        whiteListPeople.remove(person);
        queue.add(person);

        color.put(person, 0);

        // start BFS
        while (whiteListPeople.size() != 0 || queue.size() != 0) {
            // pick one person from known persons and add it to the toVisit queue

            person = null;
            if (queue.size() > 0)
                // pick another element from the queue
                person = queue.get(queue.size() - 1);
            else {
                // there are distinct components in the graph
                person = whiteListPeople.get(0);
                whiteListPeople.remove(person);
                queue.add(person);
                for (String aux : liars.get(person))
                    if (color.containsKey(aux)) {
                        color.put(person, (color.get(aux) + 1) % 2);
                        break;
                    }
            }
            for (String neighbour : liars.get(person)) {
                // unvisited node
                if (whiteListPeople.contains(neighbour)) {
                    whiteListPeople.remove(neighbour);
                    queue.add(0, neighbour);
                    color.put(neighbour, (color.get(person) + 1) % 2);
                }
            }
            queue.remove(person);

        }
        // test
        boolean different = true;

        int firstGroup = 0;
        int secondGroup = 0;
        for (String snitch : liars.keySet()) {
            for (String neighbour : liars.get(snitch)) {
                if (color.get(snitch) == color.get(neighbour))
                    different = false;
            }
        }
        for (String dude : knownPeople) {
            if (color.get(dude) == 0)
                firstGroup++;
            else
                secondGroup++;
        }
        System.out.println(Math.max(firstGroup,secondGroup)+" "+Math.min(firstGroup,secondGroup));

}

Datele de intrare se citesc din fișierul matrix.in, care conține:

• pe prima linie dimensiunile matricei: N M (N numarul de linii/ M numarul de coloane)
• pe urmatoarele N linii cate M valori reprezentand valorile din matricea de intrare (separate prin cate un spatiu)
• matricea initiala are cel puțin un element strict pozitiv.

Suma maxima se va scrie in fișierul matrix.out:

• Suma elementelor zonei găsite.

Exemplu:
Fișierul de intrare matrix.out conține:

3 3
-1 3 4
-2 3 1
1 2 -4

matrix.out conține:

11

Explicație: A fost determinată zona dreptunghiulară cu colțurile (0,1), (1,2):

3 4
3 1

Barem:

• 3p – descrierea în README.txt a algoritmului, complexitate, de ce functionează – se acordă maximul doar dacă complexitatea este cea optimă;
• 2p – funcționarea pe exemple precum cele din enunț;
• 5p – Cod funcțional de complexitate optimă (n^3);
  • +/- 1p Coding style;
  • -2p Complexitate neoptimă (n^4);
  • -4p Complexitate total neoptimă (bruteforce, n^6);
• Punctajul este intre 0-10.

Soluție

Algoritm:

1. Pentru fiecare pereche (i,j) se construiește un vector unde elementul de pe poziția k reprezintă suma de pe coloana k din matrice, între liniile i și j.
2. Pentru fiecare vector astfel obținut se construiește subvectorul de sumă maximă.

Implementare java:

public class MaxSum {
    public static void printMatrix(int[][] matrix, int n, int m) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print(String.format("%2d ", matrix[i][j]));
            }
            System.out.println("");
        }
    }
    private static int startI,endI,startJ,endJ;
    private static int seqStart,seqEnd;
    private static int maxSubSum(int[] a) {
        int maxSum = 0;
        int thisSum = 0;
        int i = 0;
        int j = 0;

        while (j < a.length) {
            if (a[j] < 0) {
                thisSum = 0;
                j++;
                continue;
            }
            thisSum = thisSum + a[j];

            if (thisSum > maxSum) {
                maxSum = thisSum;
                seqStart = i;
                seqEnd = j;
            } else if (thisSum < 0) {
                i = j + 1;
                thisSum = 0;
            }
            j = j + 1;
        }

        return maxSum;
    }

    public static void main(String[] args) {
        int matrix[][] = new int[][]{{-1, 2, 2, -4}, {1, 5, 6, -3}, {4, -2, 3, -1}, {4, 1, 2, 3}};

        int sumMatrix[][] = new int[matrix.length][matrix[0].length];
        int n = matrix.length;
        int m = matrix[0].length;
        printMatrix(matrix, n, m);

        System.out.println("");
        for (int i = 0; i < m; i++) {
            int sum = matrix[0][i];
            sumMatrix[0][i] = matrix[0][i];
            for (int j = 1; j < n; j++) {
                sum += matrix[j][i];
                sumMatrix[j][i] = sum;

            }
        }
        printMatrix(sumMatrix, n, m);

        int max = Integer.MIN_VALUE;

        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {
                int tempVector[] = new int[m];
                for (int k = 0; k < m; k++) {
                    int aux;
                    if (i != j) {
                        aux = sumMatrix[j][k];
                        if (i > 0)
                            aux -= sumMatrix[i - 1][k];
                    } else
                        aux = matrix[i][k];
                    tempVector[k] = aux;
                    if(max<maxSubSum(tempVector)){
                        max=maxSubSum(tempVector);
                        startI=i;
                        endI=j;
                        startJ=seqStart;
                        endJ=seqEnd;
                    }

                }

            }
        }
        System.out.println(max);
        System.out.println(String.format("%d %d %d %d",startI,endI,startJ,endJ));

    }
}

Pentru a oxigena organul destinație, o celulă k dintr-o secvență (i..j) va rămâne fixă în locația acestuia. Dacă celula k se desprinde din interiorul secvenței, va despărți această secvență în 2 noi sub-secvențe – (i..(k-1)) si ((k+1)..j) – care parcurg mai departe distanțele în mod independent una de cealaltă. Dacă celula k se desprinde de la unul din capetele secvenței, secvența rămasă va fi continuă – ((i+1..j) sau (i..j-1)) –.

Determinați consumul de energie minim necesar pentru ca toate organele să fie oxigenate.

Datele de intrare se citesc din fișierul blood.in, care conține:

• prima linie a fisierului doua numere intregi N si M (N numărul de celule, M numărul de vase de sânge);
• pe următoarele M linii câte 3 numere x y c , ce semnifică cu existența unui drum de la organul x la organul y, de lungime c.

Datele de ieșire se scriu în fișierul blood.out:

• Un singur număr întreg reprezentând valoarea energiei minime.

Restricții și precizări:

• N <= 100;
• Valoarea energiei minime <= (1<<31);
• Dacă o secvență de celule i-j trece prin punctul de destinație al uneia dintre celulele aflate în această secvență, nu este obligatoriu ca această celulă să rămână la destinație;
• O celulă nu poate să părăsească secvența decât dacă a ajuns la destinație și rămâne acolo;
• Inima reprezintă punctul 0.

Exemplul 1:

Fișierul de intrare blood.in conține:

4 6
0 1 1
0 2 3
0 3 5
1 2 1
1 4 2
3 4 6

Fișierul de ieșire blood.out conține:

11

Explicație:

• Celulele pleaca impreuna din punctul 0 si parcurg dinstanta 0->1 consumand 1 unitate de energie. Aici celula 1 se desprinde și rămâne la destinație;
• Secventa 2,3,4 parcurge distanța 1->2  și consumă 1 unitate de energie. Aici celula 2 rămâne la destinație.
• Celulele 3,4 se intorc in 1, cost 1
• Celulele 3, 4 parcurg distanța 1->4 și consumă 2 unități de energie. Aici celula 4 rămâne la destinație.
• Celula 3 parcurge distanța 4->3 și consuma 6 unitati de energie. În acest moment toate celulele au ajuns la destinație.
• 2 + 1 + 3 + 6 = 11

Exemplul 2:

Fișierul de intrare blood.in conține:

4 6
0 1 3
0 2 2
0 3 5
1 2 1
1 4 2
3 4 6

Fișierul de ieșire blood.out conține:

12

Explicație:

• Celulele pleaca impreuna din punctul 0 si parcurg dinstanta 0->2 consumând 2 unități de energie. Aici celula 2 se desprinde și rămâne la destinație. Rezultă secvențele 1 și 3,4
• Celula 1 parcurge distanța 2->1 și rămâne la destinație. se consumă 1 unitate de energie;
• Secventa 3,4 parcurge distanța 2->1  și consumă 1 unitate de energie;
• Secventa 3,4 parcurge distanța 1->4  și consumă 2 unități de energie. Celula 4 ramâne la destinație;
• Celula 4 parcurge distanța 3->4 și consumă 6 unități de energie. Celula 4 ramâne la destinație;
• 2 + 1 + 1 + 2 + 6 = 12

Barem:

• 3p – descrierea în README.txt a algoritmului, complexitate, de ce functionează – se acordă maximul doar dacă complexitatea este cea optimă;
• 2p – funcționarea pe exemple precum cele din enunț;
• 5p – Cod funcțional de complexitate optimă;
  • +/- 1p Coding style;
  • -2p Complexitate neoptimă;
  • -4p Complexitate total neoptimă;
• Punctajul este intre 0-10.

Soluție
Algoritm (updated)

1. Se face un Roy-Floyd sau Dijkstra din fiecare dintre puncte pentru a afla distanțele minime dintre toate punctele. (Fie matricea X, unde X[i][j] reprezinta distanta minima de la i la j)
2. Se pleacă cu reconstituirea soluției de la final, adică fiecare celulă se află la destinație și reconstituim drumul fâcut de ele.
3. Se face o dinamică pe o matrice 3D unde A[i][j][k] reprezintă energia minimă cu care secvența de celule i-j (inclusiv extremitățile) a ajuns în punctul k.
• Inițial:A[i][i][i] = 0, restul matricei INF.
• recurență: A[i][j][k] = min[A[i][k-1][t] + X[t][k] – pentru orice t din (i..k-1)] + min[A[i][k-1][r] + X[r][k] – pentru orice r din (k+1..j)].
• Pentru ca orice legatura a secventei i – j se poate face doar in nodurile i –  1 sau j – 1 se observa ca este necesar doar calculul punctelor de forma A[i][j][i-1] si A[i][j][j+1], iar calculul lui A[1][n][0] devine min(X[0][t] + A[1][n][t]) t din (1..n), aceasta optimizare reducand la O(n^3) complexitatea.

Complexitatea soluției este O(n^3).

• 6p. Readme/ API + comentarii alegere/ Folosire API (cel putin un request functional);
  
• 4p. Functionalitatea problemei;
  
• +/- 1p Coding style;
  
• Punctajul este intre 0-10.

Soluție:

Nu există.

De ce?

Problema din enunț este de tip “open question” , iar API-ul de Flickr nu e suficient pentru a găsi un răspuns. As simple as that.

Ce vrem să vedem din codul trimis este modalitatea de abordare a problemei și inventivitatea voastră.

Ca guideline pentru stilul de codare, am adaugat mai jos o mică implementare în Java în care se utilizează biblioteca FlickrJ.

Rezultatul execuției acestei funcții este afișarea primelor 10 poze ca “interestingness” din fiecare din primele 5 locații din locații de top dintr-o anumită dată (adică 50 de poze în total). Pentru filtrul de căutare se poate utiliza și relevance în loc de interestingness, deci e ok și o astfel de implementare.

public void showActivity() throws FlickrException, IOException, SAXException {

        SearchParameters searchParameters = new SearchParameters();

        // create a date 2 months ago
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.MONTH,-2);
        Date lastDate = calendar.getTime();

        // get top places by location on the specified date
        PlacesList topPlaces = f.getPlacesInterface().getTopPlacesList(7,lastDate,null,null);

        for (int i=0;i<5;i++){

            Place place = (Place)topPlaces.get(i);
            System.out.println(place.getWoeId()+" - "+place.getName());

            // set search params to woe id, sort by interestingness,on max date
            searchParameters.setWoeId(place.getWoeId());
            searchParameters.setSort(SearchParameters.INTERESTINGNESS_DESC);
            searchParameters.setMaxTakenDate(lastDate);

            // get photos for location with search params and print some info
            PhotoList fotosForLocation = f.getPhotosInterface().search(searchParameters,20,1);
            for(int j=0;j<fotosForLocation.size();j++){
                Photo foto = (Photo)fotosForLocation.get(j);
                System.out.println(foto.getTitle()+ " "+foto.getUrl()+" "+foto.getComments());
            }

            // seems like i have to throttle this
            try{
                Thread.sleep(2000);
            }
            catch (InterruptedException e){

            }

        }
    }

Aveți libertatea de a adăuga sau nu, text sau elemente vizuale care credeți voi că ar putea fi importante pentru o versiune funcțională a website-ului așa cum îl veți regândi voi.
Câteva clarificări, lucruri de urmărit, recomandări:

Prima parte: Ar fi bine să faceți câte o versiune wireframe a fiecăreia dintre următoarele pagini: landing page (http://www.wikipedia.org/), English main page (http://en.wikipedia.org/wiki/Main_Page), pagina unui articol, la alegere (de exemplu: http://en.wikipedia.org/wiki/Sibiu)

O scurtă descriere a problemelor din designul existent și argumentări ale deciziilor de design pe care le luați voi, pentru a rezolva aceste probleme.

A doua parte: Un design (hi fidelity) al paginii principale in engleza: http://en.wikipedia.org/wiki/Main_Page

Lucruri de urmărit: Păstrați brand-ul curent al Wikipedia (nume, logo, etc). Focusați-vă pe îmbunătățirea layout-ului, a structurii și a prezentării conținutului. Gandiți-vă ce puteți îmbunătăți la “main page” pentru a fi mai atrăgătoare vizual, pentru a face oamenii să o adauge la favorites, pentru a ajuta oamenii să caute și să găsească mai repede ceea ce îi interesează.

Trimiteți-ne rezultatul muncii voastre într-o formă (digitală) care să poate fi ușor citită, distribuită și analizată. De exemplu PDF, dar nu e neaparat necesar.

Tocmai te-ai angajat la compania care dezvoltă platforma de blogging WordPress și cum nu s-ar putea mai bine, vei incepe cu o testare generală a produsului.

Ai la dispoziție mai multe configurații cu care să începi de la zero (adică conțin doar instalări ale sistemului de operare), iar printre responsabilitatile tale se numără:

• Crearea unui test plan (care conține tot ceea ce crezi tu că ar trebui să conțină un astfel de document);
  
• Scrierea unei liste de teste funcționale si non-funcționale care le vei rula pentru testarea WordPress-ului;
  
• Automatizarea testelor mentionate mai sus, utilizând un framework de testare la alegere;
  

Problema 2:

Ești in prima lună de angajare la banca favorită, in cadrul departamentul IT, iar primul tău assignment este să testezi funcționarea software-ului noului ATM. Proiectul este ultra-secret, dar fiindcă interfața este scrisă în Flex cu ajutorul Adobe, ne vei ajuta să testam cât mai bine software-ul. Astfel, va trebui să:

• Creezi un test plan (care sa descrie tot ceea ce crezi tu că ar trebui să conțină un astfel de document);
  
• Scrii o listă de teste funcționale și non-funcționale pe care le vei rula pentru a certifica buna funcționare;
  
• Automatizezi o parte din testele funcționale și non-funcționale identificate, utilizând un framework de testare la alegere;
  
• Ne trimiți numele băncii preferate ca să știm cu cine faci banking
  

   

Baremul, sau la ce ne uităm:

• Structura si corectitudinea planului de teste;
  
• Granularitatea si calitatea testelor funcționale și nefuncționale;
  
• Claritatea și ușurința de utilizare a testelor automate;