Quelques exos sympa

L'auteur de ce sujet a trouvé une solution à son problème.
Auteur du sujet

Hello,

Je suis sûr que certains d'entre vous on entendu parler du concours du meilleur dev de France de l'école 42. J'avais commencé les exos il y a quelques temps et comme je vais m'y remettre je voudrais partager avec vous au cas où vous voudriez vous entrainer en attendant les prochains défis de clems.

C'est ici : http://www.isograd.com/FR/solutionconcours.php?contest_id=9 Vous pouvez-même valider votre algo en ligne pour certains langages.

Amusez-vous bien.

+1 -0

Hello,

J'avais participé à l'édition 2015 et terminé tous les exos sauf le dernier, donc je partage mon code ici (mais avant de regarder essayez de chercher un peu par vous même).

Disclaimer : ça risque de pas être très propre puisque j'avais fais ça dans le feu de l'action.

Exo 1 :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys

lines = []
for line in sys.stdin:
    lines.append(line.rstrip('\n'))

moneyStart = int(lines[0])
playedTurn = int(lines[1])
for i in range(playedTurn):
    x, y = lines[i+2].split(' ')
    moneyStart += -int(x) + int(y)

print(moneyStart)

# Vous etes 120eme ! Le premier a 431 secondes d'avance sur vous.

Exo 2 :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys
import operator

lines = []
for line in sys.stdin:
    lines.append(line.rstrip('\n'))

nbTag = int(lines[0])
dic = {}
for i in range(nbTag):
    tag = lines[i+1].strip()
    if tag in dic:
        dic[tag] += 1
    else:
        dic[tag] = 1

def funcKey(item):
    local_print(item)
    return item[1]

sorted_dic = sorted(dic.items(), key=operator.itemgetter(1), reverse=True)

out = sorted_dic[:5]
out2 = []
for tup in out:
    print(tup[0]+' '+str(tup[1]))


# Vous etes 95eme ! Le premier a 1131 secondes d'avance sur vous.

Exo 3 :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""

pas de doublons : nom, prenom et societe
format de tel valide : +[1-3]-[9-11]
ma zone : son pays est inclus dans votre liste de pays

lastname, firstname, company, phone, country

"""

import sys

lines = []
for line in sys.stdin:
    lines.append(line.rstrip('\n'))

nbLine = int(lines[0])
countries = lines[1].split(';')
data = []
for i in range(nbLine):
    data.append(lines[i+2].split(';'))

errorDouble = 0
errorTel = 0
errorZone = 0


def checkDouble(tup, i):
    for cmpTup in data[:i]:
        if cmpTup == tup:
            return True
    return False

def checkTel(tup, i):
    phone = tup[3]
    try:
        xplus, y = phone.split('-')
    except ValueError:
        return True
    x = xplus.strip('+')
    xok = len(x) >= 1 and len(x) <= 3
    yok = len(y) >= 9 and len(y) <= 11

    return not (xok and yok)

def checkZone(tup, i):
    return not (tup[4] in countries)


i = 0
for tup in data:
    if checkDouble(tup, i):
        errorDouble += 1
    else:
        if checkTel(tup, i):
            errorTel += 1
        if checkZone(tup, i):
            errorZone += 1
    i += 1

print(' '.join((str(errorDouble), str(errorTel), str(errorZone))))

# Vous etes 45eme ! Le premier a 1477 secondes d'avance sur vous.

Exo 4 :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""

40 foix 60 mn
1 tag = 1 mn

"""

default = 'Pas de trending topic'

import sys

lines = []
for line in sys.stdin:
    lines.append(line.rstrip('\n'))

nbTag = int(lines[0])
tags = []
for i in range(nbTag):
    tags.append(lines[i+1].strip())

i = 0
end = len(tags) - 59
for startTag in tags[:end]:
    window = tags[i:i+60]
    c = window.count(startTag)
    if c >= 40:
        print(startTag)
        exit()
    i += 1

print(default)

# Vous etes 31eme ! Le premier a 1574 secondes d'avance sur vous.

Exo 5 :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""

data = (type, length)

M-M, F-M, M-F ou F-F

"""


import sys

lines = []
for line in sys.stdin:
    lines.append(line.rstrip('\n'))

nb = int(lines[0])
data = []
for i in range(nb):
    data.append(lines[i+1].split(' '))

data_mm = sorted([int(tup[1]) for tup in data if tup[0] == 'M-M'], reverse=True)
data_fm = sorted([int(tup[1]) for tup in data if (tup[0] == 'M-F' or tup[0] == 'F-M')], reverse=True)
data_ff = sorted([int(tup[1]) for tup in data if tup[0] == 'F-F'], reverse=True)

local_print(len(data_mm))
local_print(data_mm)
local_print(len(data_fm))
local_print(data_fm)
local_print(len(data_ff))
local_print(data_ff)

len_fm = sum([i for i in data_fm])
max_len_ffmm = min((len(data_mm), len(data_ff)))

local_print(max_len_ffmm)

for i in range(max_len_ffmm):
  len_fm += data_mm[i]+data_ff[i]
  if max_len_ffmm != len(data_ff) and max_len_ffmm != len(data_mm):
      len_fm += max((data_mm[max_len_ffmm], data_ff[max_len_ffmm]))

print(len_fm)

# Vous etes 8eme ! Le premier a 879 secondes d'avance sur vous.

Exo 6 :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys

lines = []
for line in sys.stdin:
    lines.append(line.rstrip('\n'))

height, width = lines[0].split(' ')
height = int(height)
width = int(width)
data = []
for i in range(height):
    tmp = []
    for letter in lines[i+1].strip():
        tmp.append(letter)
    data.append(tmp)

for j in range(height):
    for i in range(width):
        if data[j][i] == '#':
            data[j][i] = 50*50
        if data[j][i] == '.':
            data[j][i] = 0

vect = (
    (-1, 0),
    (1, 0),
    (0, -1),
    (0, 1),
)

todo = []
for j in range(height):
    for i in range(width):
        todo.append((j, i))

while len(todo):
    y, x = todo[0]
    todo = todo[1:]

    #local_print(str(y) + ' ' + str(x) + ' ' + str(data[y][x]) + '|')
    if data[y][x] != 0:
        # get min of neighbourgh + 1 then recurs
        for dy, dx in vect:
            #local_print(str(data[y+dy][x+dx] + 1) + '<' + str(data[y][x]) + '|')
            if data[y+dy][x+dx] + 1 < data[y][x]:
                data[y][x] = data[y+dy][x+dx] + 1
                for dy2, dx2 in vect:
                    todo.append((y+dy2, x+dx2))


#local_print(data)

#local_print(data)
#local_print('##########')

m = 0
for j in range(height):
    for i in range(width):
        if data[j][i] > m:
            m = data[j][i]
print(str(m))

# Vous etes 18eme ! Le premier a 3050 secondes d'avance sur vous.

http://nodraak.fr/ – Dictateur bienveillant de l'iTeam, logiciel libre et sécurité à l'ECE Paris

+1 -0
Auteur du sujet

Classe, là je viens de terminer Trending topics, j'ai juste lu l'exo Rallonges et ça à pas l'air simple.

Sinon de toute façon il y a les réponses de fourni pour les langages proposés. A regarder une fois passé sinon pas d'intérêt.

Merci pour ton partage.

+0 -0

Je viens de regarder la solution C++ pour Rallonges et franchement, j'espère que c'est pas le genre de code qu'ils apprécient. Parce qu'il y a un certain nombre de standards qui leur accorderait le prix du pire dev de France.

Entre les defines particulièrement douteux, la quantité de fonctions inutiles, les principes d'indentation qui sont piétinées allègrement, les noms de variables toujours plus clairs (T, sérieusement?) et le petit using namespace std (dans un fichier définissant une classe…), ya de quoi faire s'arracher les yeux à pas mal de puristes. Et le plus choquant dans tout ça, c'est que le mec connait un minimum la lib standard puisqu'il utilise le header algorithm.

+3 -0

Ah ouais. Le code C++, c'est du grand n'importe quoi. Ils lisent les lignes à coups de getline pour découper avec des substr. Là où un simple >> suffit.

Exo poker:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
#include <iostream>
int main ()
{
    long somme;
    std::cin >> somme;

    std::size_t tours;
    std::cin >> tours;

    long x, y;
    for (size_t i=0; i!=tours && std::cin >> x >> y; ++i) {
        somme += y - x;
    }
    
    std::cout << somme;
}

L'utilisation de map est bien inutilement compliquée aussi. J'ai envie de dire que le dev qui a écrit les corrections n'a qu'une connaissance partielle de la lib standard du langage.

J'avais préparé ça, mais contrairement à France-l0l, le compilo n'est pas en mode C++14 (ce n'est pas dit que cela soit juste):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <iostream>
#include <map>
#include <string>
#include <vector>
#include <algorithm>
int main ()
{
    std::size_t nb_tags;
    std::cin >> nb_tags;

    typedef std::map< std::string, int> map_t;
    map_t map;
    for (std::size_t i=0; i!=nb_tags ; ++i) {
        std::string tag;
        std::cin >> tag;
        ++map[tag]; // <- pas besoin de if...
    }
    
    // J'ai eu la flemme de convertir en vector<map_t::const_iterator> qui aurait été plus efficace
    std::vector<std::pair<std::string, int>> v(map.begin(),map.end());
    std::sort(v.begin(),v.end(),
            [](auto lhs, auto rhs) { // <- pas besoin de laisser le mauvais ordre
            return lhs.second > rhs.second;
            });

    for (std::size_t i=0, N=5; i!=N ; ++i) {
        std::cout << v[i].first << ' ' << v[i].second << "\n";
    }
}

EDIT: des vecteurs et autres grosses structures copiées, des char* juste pour utiliser l'op[] dans le 3e exo. Ouch.

Édité par lmghs

+0 -0
Auteur du sujet

Ce qu'il faut savoir c'est que c'est un concours de rapidité. Le gagnant est le premier à avoir terminé tous les éxos (ou celui ayant était le plus loin le plus rapidement si personne n'est arrivé au bout), donc forcément les codes sont pas jolie à voir. Il y a certaines correction beaucoup plus clean (certaines en Python notamment) mais faite par des personnes travaillant pour le site donc ils ont quand même du faire propre.

L'intérêt est donc plus les problèmatique et la correction automatique que les corrections. :)

+0 -0
Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte