I, NaPs

Ya longtemps, avec Gamo, Batchy et compagnie, on se lançait des défis de programmation sur un thème bien précis, ça donnais parfois des trucs genre « programme moi un serveur http en 2h », ou bien des défis un peu plus tendus, basés sur l'élaboration d'un algorithme un peu tordu, mais toujours très intéressant.

Vu que moi ça me manque, et qu'on avait dit un jour que l'on recommencerais, et ben voilà !

Pour ce premier défi (depuis longtemps), je vais commencer par un truc assez simple, que Gamo nous avait déjà fait découvrir : les fonctions récursives. Je n'en dit pas plus, je vous laisse chercher si vous avez besoin de plus d'informations.

Le but du jeu va être de programmer une fonction qui aura le comportement suivant :

vagues(5, 3)
Affichera :

S
SS
SSS
SSSS
SSSSS
SSSS
SSS
SS
S
SS
SSS
SSSS
SSSSS
SSSS
SSS
SS
S
SS
SSS
SSSS
SSSSS
SSSS
SSS
SS
S

Le premier argument est la hauteur des vagues (en nombre de caractères), le second argument est le nombre de vagues

Le truc, c'est que vous n'avez pas le droit d'utiliser de structures de boucles dans votre programme (et la, je vous renvois 2 paragraphes plus haut). Vous ne devez pas non plus utiliser des spécificités de votre langage qui pourraient vous aider à résoudre ce problème.

Pour les règles, y'en a pas vraiment. Vous utilisez le langage que vous voulez, il n'y a rien à gagner, et je vous encourage à partager toute la doc utile que vous trouverez. Pour le code, le mieux est de l'héberger sur des sites de collage, sur un repository (cvs, svn, hg, ce que vous voulez tant qu'on peut accéder au code facilement avec un navigateur), ou encore sur votre hébergeur préféré. En fait, ce qu'il ne faut surtout pas, c'est le poster dans les commentaires, car vous perdriez l'indentation et la chasse fixe.

Pour ma part, je vais le faire en python (et peut être aussi en perl, on verra :))

Bon alors, voila les propositions, d'abbord, celle de Sunny en ruby:

#!/usr/bin/ruby
# Vagues, de Sunny Ripert
#    implémentation ruby de http://inaps.org/journal/defiprog-1
# Sous licence WTFGL - http://sam.zoy.org/wtfpl/

class Vague
 def initialize height, count
   @maxheight, @maxcount = height.to_i, count.to_i
   raise ArgumentError, \"Height must be bigger than 2\" if @maxheight < 2
   raise ArgumentError, \"Count must be bigger than 1\" if @maxcount < 1
   @count, @height = 0, 1
   @output = \"\"
   crest
   waves
 end
 def waves
   @height = 1
   @count += 1
   wave
   waves unless @count == @maxcount
 end
 def wave
   @height += 1
   crest
   wave unless @height == @maxheight
   @height -= 1
   crest
 end
 def crest
   @h = 0
   oscillation
   @output += \"\\n\"
 end
 def oscillation
   @h += 1
   @output += \"S\"
   oscillation unless @h == @height
 end
 def to_s
   @output
 end
end

if __FILE__ == $0
 abort \"Usage: #{$0} height count\" if ARGV.size < 2
 puts Vague.new(ARGV[0], ARGV[1]) rescue puts($!)
end

Ou par ici en couleur. Ensuite, celle de Batchy, en C(kipu :))

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

char* waves_backend(int depth, int times) {
   char *ret = NULL ,*othret;
   if (times > 0) {
       printf(\"%s\", ret = waves_backend(depth,times-1));
   } else if (times == 0) {
       puts(\"S\");
       ret = calloc(((depth + 2) * depth - 2 ), sizeof *ret);
       strcat(ret, othret = waves_backend(depth - 1, -1));
       free(othret);
       strcat(ret, othret = waves_backend(depth - 2, -2));
       free(othret);

   } else if (depth > 0) {
       ret= calloc((((depth + 4) * (depth + 1)) / 2 + 1), sizeof *ret);

       if (times == -2)
           strcat(strcpy(ret, othret=waves_backend(-depth, -1)),\"\\n\");
       else
           strcpy(ret, othret = waves_backend(depth - 1, -3));

       free(othret);

       if (times == -2)
           strcat(ret, othret = waves_backend(depth - 1,-2));
       else
           strcat(strcat(ret, othret = waves_backend(-depth, -1)),\"\\n\");

       free(othret);

   } else if (depth == 0) {
       ret=calloc(3, sizeof *ret);
       if (times != -3)
           strcpy(ret, \"S\\n\");
   } else {
       ret=calloc(2 - depth, sizeof *ret);
       strcpy(ret, othret = waves_backend(depth + 1, -1));
       ret[-depth] = \'S\';
       free(othret);
   }
   return ret;
}

void waves(int depth, int times) {
   if (depth > 1 && times > 0)
       free(waves_backend(depth, times));
}
int main(int argc, char *argv[]) {
   if (argc < 3)
       puts(\"usage: <depth of waves> <number of waves>\");
   else
       waves(atoi(argv[1]), atoi(argv[2]));
   return 0;
}

Ou par ici en couleur. La mienne, en python :

#!/usr/bin/env python

from sys import stdout

def row(size, i=0):
   if i != size:
       stdout.write(\'S\')
       row(size, i+1)

def aWave(size, i=1, d=1):
   if i == size:
       row(i)
       stdout.write(\'\\n\')
       aWave(size, i=i-1, d=0)
   elif i==0:
       return
   elif d:
       row(i)
       stdout.write(\'\\n\')
       aWave(size, i=i+1)
   else:
       row(i)
       stdout.write(\'\\n\')
       aWave(size, i=i-1, d=0)        

def waves(size, number, i=0):
   if i != number:
       aWave(size)
       waves(size, number, i=i+1)
vagues = waves

vagues(5, 2)

Et enfin, la version de gamo, en bash, très gore :

#!/bin/sh
# !!! the script must be chmod +x !!!
# at least i think so
if [ ${#*} -lt 3 ]; then
   $0 $* $(($1 -1)) -
   exit
fi

maxc=$1; wave=$2; curr=$3; op=$4

ndisp=$(($maxc - $curr))
seq -w -s\" \" $ndisp | sed -e \'s/[0-9]*/#/g\' -e \'s/ //g\'

if [ $ndisp -eq $maxc ]; then
   op=\"+\"
elif [ $ndisp -eq 1 ]; then
   op=\"-\"; wave=$(($wave - 1))
   if [ $wave -lt 0 ]; then exit; fi
fi

. $0 $maxc $wave $(expr $curr $op 1) $op

Encore une de gamo, en C :

/* be a nazi and compile with:
* gcc -Wall -ansi -posix -pedantic cwaves.c -o toto
*
* OFC!
*/

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

void tibal(unsigned int n)
{
   if (n)
   {
       write(1, \"\\x23\", 1);
       tibal(--n);
   }
   else
       write(1, \"\\x0a\", 1);
}

unsigned char cwaves(unsigned int maxc, unsigned int wave,
                    unsigned int curr, char op)
{
   unsigned int ndisp = maxc - curr;

   /* hi2u2 :) */
   tibal(ndisp);

   if (!(ndisp ^ maxc))
         op = 1;
   else if (ndisp == 1)
   {
       op = -1;
       wave -= 1;
       
       if (!wave)
           return EXIT_SUCCESS;
   }
   cwaves(maxc, wave, curr+op, op);
   /* never happens but nazi gcc stfu with this */
   return EXIT_SUCCESS;
}


int main(int argc, char **argv)
{
   return (argc != 3)?EXIT_FAILURE:cwaves(atoi(argv[1]), atoi(argv[2]) + 1,
                                          atoi(argv[1]) - 1, -1);
}