/* Topic des codeurs [8] */

grim7reaper · Le 30/03/2013, à 13:17

The Uploader a écrit :

Y'a vraiment besoin d'un framework (autre que celui fourni avec Python) si il part sur de l'XML pour les données ?

Pour du XML je ne sais pas.
Mais je rejoins HP, je ne suis pas sûr que le XML soit le plus simple pour faire du tri un peu complexe, mais je me trompe peut-être.

Après, s’il veut partir sur de le DB sans passer par un framework il y a un module sqlite qui vient avec Python.

Dernière modification par grim7reaper (Le 30/03/2013, à 13:18)

Pylades · Le 30/03/2013, à 13:43

Yep, Flask c’est cool. Et l’autre, c’est Bottle, mais je préfère Flask.

Sinon, ça m’a l’air plus compliqué que ça : c’est de la DB, et donc des emmerdements.

Elzen · Le 30/03/2013, à 23:24

Rolinh a écrit :

Tu mélanges plusieurs choses là nan? Suivant le niveau d'abstraction, il n'a même pas besoin de connaitre SQL. D'ailleurs, s'il veut faire ça en Python, j'imagine qu'il va plutôt faire de l'ORM (typiquement s'il choisit de faire ça avec framework tel que Django).
D'ailleurs, je ne vois pas pourquoi tu dis SQL ou DOM. Ce sont deux choses complètement différentes. Dans un cas, on a un langage pour manipuler des bases de données et dans l'autre une façon de modéliser indépendante d'un langage de programmation précis.

Hmm. Ç'vrai que les gens normaux utilisent des tas de trucs super sophistiqués au lieu de prendre directement le truc de base.
Moi j'ai juste le réflexe « Base de données → avec quoi je lance mes requêtes SQL ? » et « Lecture XML → ç'quoi, la bibli qui gère DOM dans ce langage ? ».

HP a écrit :

Pour le stockage, XML, je veux bien, mais pour le tri fin (voire complexe), sur plusieurs critères… bon courage !

Bah justement : il stocke les infos dans un fichier XML, et ensuite, il charge ce dont il a besoin, et il fait ses tris lui-même, pour progresser. C'est le but, de progresser, non ?

grim7reaper · Le 31/03/2013, à 03:34

Elzen a écrit :

il fait ses tris lui-même, pour progresser. C'est le but, de progresser, non ?

Mouais enfin c’est vite dis hein. Quand bien même il n’utilise pas de SGBDR, il va utiliser la fonction sort de Python et juste écrire les critères de tri, c’est un peu léger pour dire qu’il va faire ses tris lui-même
Et puis j’avais cru comprendre qu’il voulait bosser Python à priori, pas l’algorithmique. Donc BDD ou XML, ça ne va pas changer grand-chose si ce n’est la bibliothèque qu’il va utiliser.

Kanor · Le 31/03/2013, à 07:44

Elzen a écrit :

HP a écrit :
Pour le stockage, XML, je veux bien, mais pour le tri fin (voire complexe), sur plusieurs critères… bon courage !
Bah justement : il stocke les infos dans un fichier XML, et ensuite, il charge ce dont il a besoin, et il fait ses tris lui-même, pour progresser. C'est le but, de progresser, non ?

tiens c'est marrant, la dernière fois que j'ai voulu faire un fichier xml je suis passé directement par une librairie de template (http://jinja.pocoo.org/), le dom c'est un chouia chiant.

Dernière modification par Kanor (Le 31/03/2013, à 07:45)

Dr Le Rouge · Le 31/03/2013, à 14:38

Ma première pull request ! Ayé, je suis adulte

Pour ceux qui utilisent emacs, je recommande de jeter un oeil à mon fork de loccur ; qui est d'autant mieux que je n'ai pas modifié grand chose ^^

:!pakman · Le 01/04/2013, à 00:50

Le Rouge a écrit :

Ma première pull request ! Ayé, je suis adulte

dépullecé

Bon, sinon, je crois que je vais apprendre MongoDB, Symfony et JQuery...

HP · Le 01/04/2013, à 15:27

class Unicode((unicode if sys.version_info.major < 3 else str)):

nathéo · Le 01/04/2013, à 18:04

J'ai une petite question sur les pointeur et les tableaux en C, enfin, j'aimerai plus précisément savoir pourquoi les modifications que j'applique à des tableaux passés dans une fonction (swap_tab), ne se répercutent pas dans la fonction qui appelle swap_tab.
Donc là c'est la fonction qui est censée échanger la valeur des pointeurs pour les deux tableaux :

void    swap_tab(char *a, char *b, char *swp)
{
  printf("\n\nvaleur de a avant swap : %s \nvaleur de b avant swap : %s \n", a, b);
  swp = a;
  a = b;
  b = swp;
  printf("\nvaleur de a apres swap : %s \nvaleur de swp : %s \nvaleur de b apres swap : %s \n\n", a, swp,  b);
}

Et la c'est l'appel de la fonction :

swap_tab(tab[i], tab[(i + 1)], swp);

En sachant que printf affiche que l'échange s'est bien effectué, dans la fonction swap_tab.

Dernière modification par nathéo (Le 01/04/2013, à 19:36)

Pylades · Le 01/04/2013, à 18:31

Oh, putain.

L’autre jour, mon père m’a soutenu que la formation à Epitech était suffisante. Ben visiblement, non.

Tu ne fait que jouer avec tes pointeurs dans ta fonction, mais tu n’inverses pas du tout tes valeurs.

void swap_tab(char** a, char** b, char** swp)
{
  *swp = *a;
  *a = *b;
  *b = *swp;
}

swap_tab(&tab[i], &tab[i+1], &swp);

Là, tu aurais un code (à la truelle) qui ferait je pense ce que tu veux.

Dernière modification par Πυλάδης (Le 01/04/2013, à 18:38)

nathéo · Le 01/04/2013, à 19:26

Je trouve que tu tapes un peu trop vite sur Epitech, alors que le problème vient plus de moi je pense…

Sinon j'ai testé ce que tu as proposé, et ça ne fonctionne pas vraiment mieux, quoique, dans la fonction swap_tab, les valeurs sont tout aussi bien échangées. Enfin, je pense que j’opterai pour la solution sans l'usage de la fonction, c'est moins beau à voir je trouve, mais il ne devrait pas avoir de soucis…

EDIT : Et bien, comme je le pensais ça fonctionne bien sans l'appel de swap_tab, mais je suis quand même assez curieux de savoir pourquoi ça ne fonctionne pas avec la fonction.

Dernière modification par nathéo (Le 01/04/2013, à 19:39)

Dr Le Rouge · Le 01/04/2013, à 19:43

Pourquoi est-ce que tu passes swp en paramètre à ta fonction ?

edit : et c'est quoi le reste du code ? Parce qu'a priori la méthode de Pylade devrait fonctionner…

Dernière modification par Dr Le Rouge (Le 01/04/2013, à 19:44)

Pylades · Le 01/04/2013, à 19:48

Bah, c’est un tampon de la bonne taille vu que l’on peut potentiellement bosser sur n’importe quelle donnée ; mais là c’est vrai que c’est inutile puisque l’on type les paramètres en char**.

@ nathéo : ceci ne fait pas ce que tu veux ?

#include <stdio.h>
void swap_tab(char** a, char** b, char** swp)
{
  *swp = *a;
  *a = *b;
  *b = *swp;
}
int main(void)
{
    char* plop[] = {"one", "two", "three"};
    char* swp;
    swap_tab(&plop[1], &plop[2], &swp);
    puts(plop[0]);
    puts(plop[1]);
    puts(plop[2]);
    return 0;
}

nathéo · Le 01/04/2013, à 19:53

@ Le_Rouge Je l'ai passé en paramètre, parce que déclaré dans la fonction ça ne donnait pas grand chose.

Sinon concernant le code, il est censé donner un programme qui trie une chaîne de caractère passé en argument, donc il est un peu long, (et pas forcément commenté), enfin le voici :

#include <stdlib.h>
#include <stdio.h>

char	*epure_str(char *str);
int	my_strlen(char *str);
int	my_strcmp(char *a, char *b);

int		size_word(char *str)
{
  static int	i;
  int		word;

  word = 0;
  while (str[i] != ' ' && str[i] != '\t' && str[i] != '\0')
    {
      word += 1;
      i += 1;
    }
  i += 1;
  return (word);
}

int		fill_tab(char *tab, char *str)
{
  static int	i;
  int		n;

  n = 0;
  while (str[i] != ' ' && str[i] != '\t' && str[i] != '\0')
    {
      
      tab[n] = str[i];
      i += 1;
      n += 1;
    }
  i += 1;
  return (n);
}

char	**str_to_wordtab(char *str)
{
  char	**tab;
  int	word;
  int	chr;
  int	i;

  i = 0;
  word = count_word(str);
  tab = malloc(word*sizeof(*tab) + 1);
  tab[word] = NULL;
  while (i <= word)
    {
      chr = size_word(str);
      tab[i] = malloc(chr * sizeof(**tab) + 1);
      tab[i][chr] = '\0';
      fill_tab(tab[i], str);
      i += 1;
    }
  tab[word] = NULL;
  return (tab);
}

void	swap_tab(char *a, char *b)
{
  char	*swp;

  printf("\n\nvaleur de a avant swap : %s \nvaleur de b avant swap : %s \n", a, b);
  swp = a;
  a = b;
  b = swp;
  printf("\nvaleur de a apres swap : %s \nvaleur de swp : %s \nvaleur de b apres swap : %s \n\n", a, swp,  b);
}

void	ord_alphlong(char **tab)
{
  int	i;
  int	opr;
  char	*swp;

  opr = 1;
  while (opr == 1)
    {
      opr = 0;
      i = 0;
      while (tab[(i + 1)] != NULL)
	{
	  if (my_strlen(tab[i]) > my_strlen(tab[(i + 1)]))
	    {
	      opr = 1;
	      /*swp = tab[i];
	      tab[i] = tab[(i + 1)];
	      tab[(i + 1)] = swp;*/
	      swap_tab(tab[i], tab[(i+1)]);
	    }
	  if (my_strlen(tab[i]) == my_strlen(tab[(i + 1)]))
	    if (my_strcmp(tab[i], tab[i + 1]) == 1)
	      {
		opr = 1;
		/*swp = tab[i];
		tab[i] = tab[(i + 1)];
		tab[(i + 1)] = swp;*/
		swap_tab(tab[i], tab[(i+1)]);
	      }
	  i += 1;
	  //my_putstr("valeur de opr : ");
	  //my_putchar(opr + 48);
	  //my_putchar('\n');
	}
      display_tab(tab);
    }
}

int	main(int ac, char **av)
{
  char	**tab;
  char	*str;
  int	cmp;

  if (ac == 2)
    {
      str = epure_str(av[1]);
      tab = str_to_wordtab(str);
      ord_alphlong(tab);
      display_tab(tab);
    }
  if (ac == 3)
    {
      cmp = my_strcmp(av[1], av[2]);
      if (cmp >= 0)
	my_putchar(cmp + '0');
      if (cmp == -1)
	my_putstr("-1");
    }
  return (0);
}

Dernière modification par nathéo (Le 01/04/2013, à 20:43)

Dr Le Rouge · Le 01/04/2013, à 19:53

swp est d'usage uniquement local, donc je vois pas l'interêt de la passer par paramètre ; ça ajoute une variable inutile dans la fonction qu'on cherche à alléger en utilisant la fonction swap_tab.

#include <stdio.h>
void swap_tab(char** a, char** b)
{
  char *swp = *a;
  *a = *b;
  *b = swp;
}
int main(void)
{
    char* plop[] = {"one", "two", "three"};
    swap_tab(&plop[1], &plop[2]);
    puts(plop[0]);
    puts(plop[1]);
    puts(plop[2]);
    return 0;
}

edit : ça ferait pas de mal d'initialiser i à 0 dans toutes les fonctions… Et c'est quoi cette indentation oO" ?

edit 2 : bon, je vais faire un post séparé…

Dernière modification par Dr Le Rouge (Le 01/04/2013, à 19:58)

nathéo · Le 01/04/2013, à 20:04

@ Pylade J'ai proprement refait le test avec ton code, et effectivement il fonctionne bien. J'ai du oublié de déférencer les variables dans swap_tab.

@ Le_Rouge : Lorsqu'on utilise une variable statique, elle est automatiquement initialisé à zéro. Et l'indentation est celle d'Emacs (plus celle qu'impose la norme d'Epitech, qui n'est pas tout le temps génial, certes ) Sinon comme je le disais, swp était à l'origine, censé être locale à swap_tab, mais comme ça ne fonctionnait comme je l'espérais, j'ai voulu essayé la passant en paramètre.

Dr Le Rouge · Le 01/04/2013, à 20:28

nathéo a écrit :

@ Le_Rouge Je l'ai passé en paramètre, parce que déclaré dans la fonction ça ne donnait pas grande.

Rien compris.

(et pas forcément commenté)

C'est au fur-et-à-mesure qu'il faut commenter T_T

Dans ce qui suit, gardez à l'esprit que je ne suis pas un programmeur ; je suis matheux de formation. Ca ne m'empêche pas de m'arracher les cheveux 'Faut croire qu'on en apprend plus dans les vraies écoles d'ingé.

Bref.
</troll>
<code_review_assassine>

#include <stdlib.h>
#include <stdio.h>

char	*epure_str(char *str);
int	my_strlen(char *str);
int	my_strcmp(char *a, char *b);

Pourquoi réimplémenter strlen et strcmp ?

int		size_word(char *str)

C'est un concours du plus gros espace inutile ?

{
  static int	i;

Il va s'initialiser tout seul le i ? Non parce que tu l'utilises dans une condition d'entrée dans une boucle sans connaître sa valeur. edit avant post : même si le mot clef static assure l'initialisation, un peu de clarté ferait du bien.

  int		word;

word est un très mauvais nom puisque ça devrait correspondre à… Un mot. Pas à sa taille. Utilise "word_length" ou que sais-je.

  word = 0;
  while (str[i] != ' ' && str[i] != '\t' && str[i] != '\0')
    {
      word += 1;
      i += 1;
    }
  i += 1;
  return (word);
}

Pourquoi utiliser une variable i ? Et pourquoi incrémenter i alors qu'il n'est plus utilisé ?

int		fill_tab(char *tab, char *str)
{
  static int	i;

L'initialisation de i ferait pas de mal. Même si le compilo comprend, un peu de clarté ne ferait pas de mal.

  int		n;

  n = 0;
  while (str[i] != ' ' && str[i] != '\t' && str[i] != '\0')
    {
      
      tab[n] = str[i];
      i += 1;
      n += 1;
    }
  i += 1;
  return (n);
}

L'indentation est toujours aussi illisible et incrémenter i à la fin ne sert toujours à rien. D'ailleurs, incrémentation mise à part, i et n auront la même valeur, donc je ne vois pas l'intérêt des deux variables.

char	**str_to_wordtab(char *str)
{
  char	**tab;
  int	word;
  int	chr;
  int	i;

  i = 0;

Hé ben voilà, là tu initialises la variable ! C'est bien, mais il ne fallait pas te sentir obliger de compenser en indentant **tab n'importe comment. Sérieux, emacs gère ça tout seul, et fort bien en plus. edit avant post : Je sais pas ce qu'il font subir à emacs chez toi mais je pense qu'on devrait prévenir les nations unies pour crimes de guerre

  word = count_word(str);
  tab = malloc(word*sizeof(*tab) + 1);
  tab[word] = NULL;
  while (i <= word)

Pourquoi pas une boucle for ici ?

    {
      chr = size_word(str);
      tab[i] = malloc(chr * sizeof(**tab) + 1);
      tab[i][chr] = '\0';
      fill_tab(tab[i], str);
      i += 1;
    }
  tab[word] = NULL;
  return (tab);
}

Tu devrais pas confier à fill_tab la tâche de mettre un '\0' à la fin de tab ?

void	swap_tab(char *a, char *b)
{
  char	*swp;

  printf("\n\nvaleur de a avant swap : %s \nvaleur de b avant swap : %s \n", a, b);
  swp = a;
  a = b;
  b = swp;
  printf("\nvaleur de a apres swap : %s \nvaleur de swp : %s \nvaleur de b apres swap : %s \n\n", a, swp,  b);
}

Tu veux modifier la valeur des tes paramètres d'entrée : ça ne marchera pas. Il faut que tu passes des pointeurs vers ces paramètres puis que tu modifies ce vers quoi pointes les-dits pointeurs (c'est ce que fait le code de Pylade).

void	ord_alphlong(char **tab)
{
  int	i;
  int	opr;
  char	*swp;

C'est quoi ce nom ? "opr" ? A quoi correspond cette variable ?

  opr = 1;
  while (opr == 1)
    {
      opr = 0;
      i = 0;
      while (tab[(i + 1)] != NULL)
	{
	  if (my_strlen(tab[i]) > my_strlen(tab[(i + 1)]))
	    {
	      opr = 1;
	      /*swp = tab[i];
	      tab[i] = tab[(i + 1)];
	      tab[(i + 1)] = swp;*/
	      swap_tab(tab[i], tab[(i+1)]);
	    }
	  if (my_strlen(tab[i]) == my_strlen(tab[(i + 1)]))
	    if (my_strcmp(tab[i], tab[i + 1]) == 1)
              {
		opr = 1;
		/*swp = tab[i];
		tab[i] = tab[(i + 1)];
		tab[(i + 1)] = swp;*/
		swap_tab(tab[i], tab[(i+1)]);
	      }

Le « et » et le « ou » logique, ça t'évoque quelque chose ? Pas besoin d'enchaîner deux if comme ça… En plus, le code dans ton premier if et dans le double if est le même. Donc au lieu de faire

if (bla)
  truc;
if (blo)
  if (blu)
    truc;

tu fais

if (bla || (blo && blu))
  truc;

Non mais franchement…

Bref.

	  i += 1;
	  //my_putstr("valeur de opr : ");
	  //my_putchar(opr + 48);
	  //my_putchar('\n');
	}
      display_tab(tab);
    }
}

int	main(int ac, char **av)
{
  char	**tab;
  char	*str;
  int	cmp;

  if (ac == 2)
    {
      str = epure_str(av[1]);
      tab = str_to_wordtab(str);
      ord_alphlong(tab);
      display_tab(tab);
    }
  if (ac == 3)
    {
      cmp = my_strcmp(av[1], av[2]);
      if (cmp >= 0)
	my_putchar(cmp + '0');
      if (cmp == -1)
	my_putstr("-1");
    }
  return (0);
}

Et encore une fois, j'ai fait plein de trucs n'ayant qu'une relation plutôt distendue avec la programmation quand j'étais en prépa puis en écoles… Le prochain qui vante Epitech, il faut lui poster un lien vers ces posts

J'espère que tu as compris les erreurs que j'ai pointées, je répondrai évidemment à tes questions. Attention, je suis à peu près sûr que même une fois cela corrigé, ça ne marchera toujours pas.

grim7reaper · Le 01/04/2013, à 20:40

Le Rouge a écrit :

(et pas forcément commenté)
C'est au fur-et-à-mesure qu'il faut commenter T_T

À Epitech ?

Le Rouge a écrit :

#include <stdlib.h>
#include <stdio.h>

char	*epure_str(char *str);
int	my_strlen(char *str);
int	my_strcmp(char *a, char *b);

Pourquoi réimplémenter strlen et strcmp ?

Epitech-style camarade, on n’apprends même pas aux étudiants comment swapper correctement deux variables (niveau second TP dans un cours d’intro’ au C…) mais on va leur refaire coder une libc bancale.

Le Rouge a écrit :

  word = count_word(str);
  tab = malloc(word*sizeof(*tab) + 1);
  tab[word] = NULL;
  while (i <= word)

Pourquoi pas une boucle for ici ?

Parce que c’est interdit par la norme Epitech pardi ! Non, ça n’est pas une blague, oui je suis sérieux -___-"
Au même titre que les switch, break, continue, goto et do while…

Le Rouge a écrit :

Le « et » et le « ou » logique, ça t'évoque quelque chose ? Pas besoin d'enchaîner deux if comme ça… En plus, le code dans ton premier if et dans le double if est le même.

Holà, là on parle d’une école qui apprends à pisser du code avec une norme à se rouler par terre (oui, parce que là tu vois que la partie visible (indentation), mais y a aussi tout un coding style à se rouler par terre (quoiqu’il me semble qu’il ai été mis à jour il y a quelque années et que c’est un tout petit moins ridicule maintenant)), va pas commencer à leur demander de réfléchir pour coder.

@natheo : arrête d’utiliser static comme tu le fais là (code smell, réentrance…, flemme d’expliquer), genre je code à La RACHE, mais bon on ne va pas non plus mettre des globales (ça serait trop visible hein), donc on va passer par du static avec effet de bord pas très visible \o/ (là preuve, Le Rouge est passé à côté).

Tiens, en parlant de La RACHE, voilà un script Ruby fait en suivant cette méthode (je le nettoierai/rendrai plus error-proof peut-être plus tard).

#!/usr/bin/env ruby
# encoding: utf-8

require 'optparse'
require 'open-uri'

require 'nokogiri'


BASE_URL = 'http://www.bugmenot.com/view/'


class Account
  attr_reader :login
  attr_reader :password
  attr_reader :success_rate
  attr_reader :status

  def initialize(login, password, stats)
    @login    = login
    @password = password
    @stats    = stats

    @success_rate = stats.to_i()
    if @success_rate > 50
      @status = :good
    elsif @success_rate < 50
      @status = :bad
    else
      @status = :average
    end
  end

  def to_s
    "login: #{@login}\npassword: #{@password}\nstats: #{@stats}\n"
  end
end


def get_accounts(url)
  accounts = []
  page = Nokogiri::HTML(open(BASE_URL << url))
  results = page.css('div[class="account"] table')
  results.each do |id|
    values   = id.css('tr td')
    accounts << Account.new(values[0].text, values[1].text, values[3].text)
  end
  return accounts
end


if __FILE__ == $0
  only_good = false
  opts = OptionParser.new do |opts|
    opts.banner = 'Usage: bugmenot [-g] url'
    opts.separator ''
    opts.separator 'Specific options:'
    opts.on('-g', '--good', 'Only print account with good success rate') do |r|
      only_good = true
    end
    opts.on_tail('-h', '--help', 'Show this message') do
      puts(opts)
      exit
    end
  end
  opts.parse!
  accounts = get_accounts(ARGV[0])
  if only_good
    accounts.select! { |account| account.status == :good }
  end
  puts(accounts.join("\n"))
end

Exemple :

./bugmenot.rb --good youtube.com
login: mxxaa000111222333
password: 000111222333
stats: 67% success rate (3 votes)

login: TaylorSwiftVEVO
password: clk yes to reveal password
stats: 63% success rate (2920 votes)

login: youtube4215
password: YES TO REVEAL PASSWORD
stats: 61% success rate (4064 votes)

login: ninjafreak74
password: Klic Yes to show spiker
stats: 57% success rate (17947 votes)

login: Youtuber4215
password: YES TO REVEAL PASSWORD
stats: 56% success rate (1760 votes)

login: All this Accounts are Fake
password: STOP THE MADNESS
stats: 54% success rate (766 votes)

login: Ninjafreak7
password: Klic Yes to show spiker
stats: 53% success rate (1370 votes)

login: mimimoize@hotmail.com
password: klik yes to
stats: 53% success rate (7512 votes)

login: lovely4xoxo@gmail.com
password: lostcausex3
stats: 52% success rate (23 votes)

login: adil
password: addie
stats: 51% success rate (37 votes)

Dernière modification par grim7reaper (Le 01/04/2013, à 21:16)

nathéo · Le 01/04/2013, à 21:19

Le Rouge a écrit :

nathéo a écrit :
@ Le_Rouge Je l'ai passé en paramètre, parce que déclaré dans la fonction ça ne donnait pas grande.
Rien compris.

Édité.

(et pas forcément commenté)
C'est au fur-et-à-mesure qu'il faut commenter T_T
Dans ce qui suit, gardez à l'esprit que je ne suis pas un programmeur ; je suis matheux de formation. Ca ne m'empêche pas de m'arracher les cheveux 'Faut croire qu'on en apprend plus dans les vraies écoles d'ingé.
Bref.
</troll>
<code_review_assassine>
#include <stdlib.h>
#include <stdio.h>

char	*epure_str(char *str);
int	my_strlen(char *str);
int	my_strcmp(char *a, char *b);
Pourquoi réimplémenter strlen et strcmp ?

Parce que c'est obligatoire, sinon je ne pense pas que je me serais gêné…

int		size_word(char *str)
C'est un concours du plus gros espace inutile ?

Non, norme Epitech, du fait de l'utilisation de la static…

{
  static int	i;
Il va s'initialiser tout seul le i ? Non parce que tu l'utilises dans une condition d'entrée dans une boucle sans connaître sa valeur. edit avant post : même si le mot clef static assure l'initialisation, un peu de clarté ferait du bien.

Il ne faut pas oublier c'est du code censé donner un programme qui trie une chaîne de caractère, et pour ce faire je passe par un tableau à 2 dimensions qu'il faut ré-allouer, d'où l'utilisation de la variable statique d'ailleurs, qui sert à compter le nombre de caractère avant un espace, ou une tabulation ou le caractère \0 de la chaîne de caractère traitée.

  int		word;
word est un très mauvais nom puisque ça devrait correspondre à… Un mot. Pas à sa taille. Utilise "word_length" ou que sais-je.

J'avais au départ utilisé word_size, mais je l'ai changé parce que je trouvais que word était plus court… (le code était à la base, pas censé est montré à d'autres personnes )

  word = 0;
  while (str[i] != ' ' && str[i] != '\t' && str[i] != '\0')
    {
      word += 1;
      i += 1;
    }
  i += 1;
  return (word);
}
Pourquoi utiliser une variable i ? Et pourquoi incrémenter i alors qu'il n'est plus utilisé ?

La variable i sert à progresser dans la chaîne de caractère, si je puis dire, et l'incrémentation de i à la fin est là pour "sauter" l'espace.

int		fill_tab(char *tab, char *str)
{
  static int	i;
L'initialisation de i ferait pas de mal. Même si le compilo comprend, un peu de clarté ne ferait pas de mal.

Je ne peux pas me permettre d'initialiser i, sinon l'usage de la statique perdrait tout son intérêt, puisque la progression dans la chaîne de caractère justement serait stoppée.

  int		n;

  n = 0;
  while (str[i] != ' ' && str[i] != '\t' && str[i] != '\0')
    {
      
      tab[n] = str[i];
      i += 1;
      n += 1;
    }
  i += 1;
  return (n);
}
L'indentation est toujours aussi illisible et incrémenter i à la fin ne sert toujours à rien. D'ailleurs, incrémentation mise à part, i et n auront la même valeur, donc je ne vois pas l'intérêt des deux variables.

J'ai déjà expliqué à quoi servait l'incrémentation de i à la fin de la fonction, sinon concernant l'indentation, bien que la ligne sautée n'est absolument pas justifiée, pour l'identation je ne vois pas vraiment ce que tu lui reproche.

char	**str_to_wordtab(char *str)
{
  char	**tab;
  int	word;
  int	chr;
  int	i;

  i = 0;
Hé ben voilà, là tu initialises la variable ! C'est bien, mais il ne fallait pas te sentir obliger de compenser en indentant **tab n'importe comment. Sérieux, emacs gère ça tout seul, et fort bien en plus. edit avant post : Je sais pas ce qu'il font subir à emacs chez toi mais je pense qu'on devrait prévenir les nations unies pour crimes de guerre

Ce n'est pas censé être indenté comme ça, sur mon pc ça donne plutôt ça : http://paste.tdct.org/index.php?zj

  word = count_word(str);
  tab = malloc(word*sizeof(*tab) + 1);
  tab[word] = NULL;
  while (i <= word)

Pourquoi pas une boucle for ici ?

Le for est interdit par la norme Epitech, si ça ne tenait qu'à moi, je m'en serais servi.

    {
      chr = size_word(str);
      tab[i] = malloc(chr * sizeof(**tab) + 1);
      tab[i][chr] = '\0';
      fill_tab(tab[i], str);
      i += 1;
    }
  tab[word] = NULL;
  return (tab);
}

Tu devrais pas confier à fill_tab la tâche de mettre un '\0' à la fin de tab ?

Pas forcément, surtout que tab est un tableau à deux dimensions (et donc devrait ne peux contenir de '\0', mais plutôt NULL), et que fill_tab le remplis au fur et à mesure, alors je préfère le faire après que la copie des mots ait été faite, je trouve ça plus sûr.

void	swap_tab(char *a, char *b)
{
  char	*swp;

  printf("\n\nvaleur de a avant swap : %s \nvaleur de b avant swap : %s \n", a, b);
  swp = a;
  a = b;
  b = swp;
  printf("\nvaleur de a apres swap : %s \nvaleur de swp : %s \nvaleur de b apres swap : %s \n\n", a, swp,  b);
}
Tu veux modifier la valeur des tes paramètres d'entrée : ça ne marchera pas. Il faut que tu passes des pointeurs vers ces paramètres puis que tu modifies ce vers quoi pointes les-dits pointeurs (c'est ce que fait le code de Pylade).

J'ai vue oui, je n'avais pas bien regardé mes exercices sur le swap où effectivement c'est cette méthode qui avait été utilisée, enfin merci pour le rappel.

void	ord_alphlong(char **tab)
{
  int	i;
  int	opr;
  char	*swp;
C'est quoi ce nom ? "opr" ? A quoi correspond cette variable ?

"opr" pour opération, en gros tant qu'elle ne vaut pas zéro, il y a aura toujours un tri à effectuer.

  opr = 1;
  while (opr == 1)
    {
      opr = 0;
      i = 0;
      while (tab[(i + 1)] != NULL)
	{
	  if (my_strlen(tab[i]) > my_strlen(tab[(i + 1)]))
	    {
	      opr = 1;
	      /*swp = tab[i];
	      tab[i] = tab[(i + 1)];
	      tab[(i + 1)] = swp;*/
	      swap_tab(tab[i], tab[(i+1)]);
	    }
	  if (my_strlen(tab[i]) == my_strlen(tab[(i + 1)]))
	    if (my_strcmp(tab[i], tab[i + 1]) == 1)
              {
		opr = 1;
		/*swp = tab[i];
		tab[i] = tab[(i + 1)];
		tab[(i + 1)] = swp;*/
		swap_tab(tab[i], tab[(i+1)]);
	      }

Le « et » et le « ou » logique, ça t'évoque quelque chose ? Pas besoin d'enchaîner deux if comme ça… En plus, le code dans ton premier if et dans le double if est le même. Donc au lieu de faire

Si si bien sûr, mais la norme me limite à 80 caractères par colonne, du coup je suis bien obligé de faire un peu autrement…

if (bla)
  truc;
if (blo)
  if (blu)
    truc;
tu fais
if (bla || (blo && blu))
  truc;
Non mais franchement…
Bref.
	  i += 1;
	  //my_putstr("valeur de opr : ");
	  //my_putchar(opr + 48);
	  //my_putchar('\n');
	}
      display_tab(tab);
    }
}

int	main(int ac, char **av)
{
  char	**tab;
  char	*str;
  int	cmp;

  if (ac == 2)
    {
      str = epure_str(av[1]);
      tab = str_to_wordtab(str);
      ord_alphlong(tab);
      display_tab(tab);
    }
  if (ac == 3)
    {
      cmp = my_strcmp(av[1], av[2]);
      if (cmp >= 0)
	my_putchar(cmp + '0');
      if (cmp == -1)
	my_putstr("-1");
    }
  return (0);
}
Et encore une fois, j'ai fait plein de trucs n'ayant qu'une relation plutôt distendue avec la programmation quand j'étais en prépa puis en écoles… Le prochain qui vante Epitech, il faut lui poster un lien vers ces posts
J'espère que tu as compris les erreurs que j'ai pointées, je répondrai évidemment à tes questions. Attention, je suis à peu près sûr que même une fois cela corrigé, ça ne marchera toujours pas.

Mon programme fonctionne très bien, je peux même te passer les sources si tu n'es pas convaincu.

The Uploader · Le 01/04/2013, à 21:26

nathéo a écrit :

Le for est interdit par la norme Epitech, si ça ne tenait qu'à moi, je m'en serais servi.

Dernière modification par The Uploader (Le 01/04/2013, à 21:26)

Dr Le Rouge · Le 01/04/2013, à 21:30

Les variables globales, c'est mal.

Ça, ça passe dans 80 caractères :

if (my_strlen(tab[i]) > my_strlen(tab[(i + 1)])
    || (my_strlen(tab[i]) == my_strlen(tab[(i + 1)])
	&& my_strcmp(tab[i], tab[i + 1]) == 1))

opr, je l'aurais appelée "keep_going", "not_done", "continue" ou un truc du style. Diminuer le nom d'une variable pour gagner de la place, ce n'est pas une bonne idée (sauf évidemment si le nom est inutilement long mais sur un truc de deux mots, ça ne risque pas d'être le cas).
Si on vous apprend que tenir dans 80 caractères est plus important qu'éviter un truc aussi crade que ton double if, il y a du soucis à se faire.
Non seulement les boucles for sont plus claires pour l'utilisateur mais elles sont plus rapides.

Pylades · Le 01/04/2013, à 21:31

nathéo a écrit :

Je ne peux pas me permettre d'initialiser i, sinon l'usage de la statique perdrait tout son intérêt, puisque la progression dans la chaîne de caractère justement serait stoppée.

Je te conseille vivement de relire la norme à ce sujet, dan ce cas…

Elzen · Le 01/04/2013, à 21:32

Le Rouge a écrit :

Dans ce qui suit, gardez à l'esprit que je ne suis pas un programmeur ; je suis matheux de formation. Ca ne m'empêche pas de m'arracher les cheveux 'Faut croire qu'on en apprend plus dans les vraies écoles d'ingé.

Je n'irais pas jusqu'à dire que mes petits étudiants font mieux (niveau indentation, ce serait même plutôt pire ><), mais tout de même, en effet.

nathéo a écrit :

J'avais au départ utilisé word_size, mais je l'ai changé parce que je trouvais que word était plus court… (le code était à la base, pas censé est montré à d'autres personnes )

Tip : même si ce n'est que pour toi, ça peut être intéressant que tu sois en mesure de te relire plus tard, quand tu auras eu le temps d'oublier.

Toujours coder comme si ça allait être maintenu par un gros psychopathe qui connaît ton adresse.

nathéo a écrit :

Si si bien sûr, mais la norme me limite à 80 caractères par colonne, du coup je suis bien obligé de faire un peu autrement…

Faire des retours à la ligne ?

Pylades · Le 01/04/2013, à 21:36

Le Rouge a écrit :

opr, je l'aurais appelée "keep_going", "not_done", "continue" ou un truc du style.

Euh… ou pas.

nathéo · Le 01/04/2013, à 21:55

grim7reaper a écrit :

@natheo : arrête d’utiliser static comme tu le fais là (code smell, réentrance…, flemme d’expliquer), genre je code à La RACHE, mais bon on ne va pas non plus mettre des globales (ça serait trop visible hein), donc on va passer par du static avec effet de bord pas très visible \o/ (là preuve, Le Rouge est passé à côté).

D'accord, je veux bien, surtout qu'on a déjà été prévenu qu'utiliser static n'est pas forcément ce qu'il y a de plus propre, mais je ne vois pas vraiment comment faire autrement, enfin de manière aussi pratique.

Le Rouge a écrit :

Les variables globales, c'est mal.
Ça, ça passe dans 80 caractères :
if (my_strlen(tab[i]) > my_strlen(tab[(i + 1)])
    || (my_strlen(tab[i]) == my_strlen(tab[(i + 1)])
	&& my_strcmp(tab[i], tab[i + 1]) == 1))

Quatre-vingt caractères, c'est la limite pour la condition entière. (et je répond à ArkSeth du même coup)

opr, je l'aurais appelée "keep_going", "not_done", "continue" ou un truc du style. Diminuer le nom d'une variable pour gagner de la place, ce n'est pas une bonne idée (sauf évidemment si le nom est inutilement long mais sur un truc de deux mots, ça ne risque pas d'être le cas).

"opr" sonne plus comme "operation is needed" pour moi, mais quelque chose du genre de keep_swap aurait été le plus approprié je pense.

Si on vous apprend que tenir dans 80 caractères est plus important qu'éviter un truc aussi crade que ton double if, il y a du soucis à se faire.

Je suis loin d'être un fan de la norme (comme la majorité des étudiants d'ailleurs), quand on le peut, on n'hésite à s'en passer.

Non seulement les boucles for sont plus claires pour l'utilisateur mais elles sont plus rapides.

Je ne dis pas le contraire, mais il paraît que ça peut "causer des problème dans l'apprentissage du C" alors on doit s'en passer pour nos projets…

Πυλάδης a écrit :

nathéo a écrit :
Je ne peux pas me permettre d'initialiser i, sinon l'usage de la statique perdrait tout son intérêt, puisque la progression dans la chaîne de caractère justement serait stoppée.
Je te conseille vivement de relire la norme à ce sujet, dan ce cas…

norme Epitech a écrit :

Il est interdit d’affecter et de déclarer une variable en même temps, excepté lorsque
l’on manipule des variables statiques ou globales
• Abuser des static pour faire des globales est interdit. Toute variable statique doit
etre justifiée.

Il me semble que l'utilisation des statiques est assez justifiée…

Elzen a écrit :

nathéo a écrit :
J'avais au départ utilisé word_size, mais je l'ai changé parce que je trouvais que word était plus court… (le code était à la base, pas censé est montré à d'autres personnes )
Tip : même si ce n'est que pour toi, ça peut être intéressant que tu sois en mesure de te relire plus tard, quand tu auras eu le temps d'oublier.
Toujours coder comme si ça allait être maintenu par un gros psychopathe qui connaît ton adresse.

La prochaine fois j'y songerai, surtout avant de poster du code sur ce topic…

nathéo a écrit :
Si si bien sûr, mais la norme me limite à 80 caractères par colonne, du coup je suis bien obligé de faire un peu autrement…
Faire des retours à la ligne ?

Voir la réponse que j'ai donné à Le-Rouge sur le sujet.

Dernière modification par nathéo (Le 01/04/2013, à 21:59)

Ubuntu-fr

Navigation

Liens de recherche

Annonce

#976 Le 30/03/2013, à 13:17

Re : /* Topic des codeurs [8] */

#977 Le 30/03/2013, à 13:43

Re : /* Topic des codeurs [8] */

#978 Le 30/03/2013, à 23:24

Re : /* Topic des codeurs [8] */

#979 Le 31/03/2013, à 03:34

Re : /* Topic des codeurs [8] */

#980 Le 31/03/2013, à 07:44

Re : /* Topic des codeurs [8] */

#981 Le 31/03/2013, à 14:38

Re : /* Topic des codeurs [8] */

#982 Le 01/04/2013, à 00:50

Re : /* Topic des codeurs [8] */

#983 Le 01/04/2013, à 15:27

Re : /* Topic des codeurs [8] */

#984 Le 01/04/2013, à 18:04

Re : /* Topic des codeurs [8] */

#985 Le 01/04/2013, à 18:31

Re : /* Topic des codeurs [8] */

#986 Le 01/04/2013, à 19:26

Re : /* Topic des codeurs [8] */

#987 Le 01/04/2013, à 19:43

Re : /* Topic des codeurs [8] */

#988 Le 01/04/2013, à 19:48

Re : /* Topic des codeurs [8] */

#989 Le 01/04/2013, à 19:53

Re : /* Topic des codeurs [8] */

#990 Le 01/04/2013, à 19:53

Re : /* Topic des codeurs [8] */

#991 Le 01/04/2013, à 20:04

Re : /* Topic des codeurs [8] */

#992 Le 01/04/2013, à 20:28

Re : /* Topic des codeurs [8] */

#993 Le 01/04/2013, à 20:40

Re : /* Topic des codeurs [8] */

#994 Le 01/04/2013, à 21:19

Re : /* Topic des codeurs [8] */

#995 Le 01/04/2013, à 21:26

Re : /* Topic des codeurs [8] */

#996 Le 01/04/2013, à 21:30

Re : /* Topic des codeurs [8] */

#997 Le 01/04/2013, à 21:31

Re : /* Topic des codeurs [8] */

#998 Le 01/04/2013, à 21:32

Re : /* Topic des codeurs [8] */

#999 Le 01/04/2013, à 21:36

Re : /* Topic des codeurs [8] */

#1000 Le 01/04/2013, à 21:55

Re : /* Topic des codeurs [8] */

Pied de page des forums