Somme des cubes

[OG]

*** Pour masquer/découvrir le code Asymptote qui a permis de créer la figure, il faut cliquer dessus. ;-) ***

CODE ASYMPTOTE de la figure ci-dessus : Tout sélectionner

size(200,0);
import patterns;
 
add("hatch",hatch(2mm));
add("hatchback",hatch(2mm,NW));
add("crosshatch",crosshatch(2mm));
 
path p=unitsquare;
 
for(int i=0;i<15;++i)
  {
    for (int j=0;j<15;++j)
    {
      draw(shift(i,j)*p);
    }
  }
 
filldraw(p,gray);
path p1=scale(2)*p;
filldraw(shift(0,1)*p1,pattern("hatch"));
filldraw(shift(1,0)*p1,pattern("hatch"));
filldraw(shift(1,1)*p,pattern("crosshatch"));
 
path p2=scale(3)*p;
filldraw(shift(3,0)*p2,gray);
filldraw(shift(3,3)*p2,gray);
filldraw(shift(0,3)*p2,gray);
 
 
path p3=scale(4)*p;
filldraw(shift(6,0)*p3,pattern("hatch"));
filldraw(shift(4,6)*p3,pattern("hatch"));
filldraw(shift(0,6)*p3,pattern("hatch"));
 
filldraw(shift(6,4)*p3,pattern("hatch"));
filldraw(shift(6,6)*p1,pattern("crosshatch"));
filldraw(shift(8,8)*p1,white);
 
 
 
path p4=scale(5)*p;
filldraw(shift(10,0)*p4,gray);
filldraw(shift(10,5)*p4,gray);
filldraw(shift(0,10)*p4,gray);
filldraw(shift(10,10)*p4,gray);
filldraw(shift(5,10)*p4,gray);
 
for(int i=0;i<15;++i)
  {
    for (int j=0;j<15;++j)
    {
      draw(shift(i,j)*p);
    }
  }
filldraw(shift(8,8)*p1,white);
 
draw(p,black+1.5bp);
draw(scale(3)*p,black+1.5bp);
draw(scale(6)*p,black+1.5bp);
draw(scale(10)*p,black+1.5bp);
 
draw(scale(15)*p,black+1.5bp);

Permet en clignant des yeux de trouver la formule .

[mumblee]

Tu n'utilises pas le motif hatchback défini, dommage parce que je trouve qu'on cligne mieux des yeux si les pavés "verticaux" sont remplis avec hatch et les "horizontaux" avec hatchback. Du coup, avec la superposition, pas besoin du motif crosshatch.

Bref, je propose une variante du code (avec en plus, n qui vaut ce qu'on veut )

Code : Tout sélectionner

unitsize(0.5cm);
import patterns;

// choisir un entier n
int n=5;

// motifs
add("hatch",hatch(2mm));
add("hatchback",hatch(2mm,NW));

// sommes des k premiers entiers ( 1<= k <=n )
int sum(int n) {
  real somme=n*(n+1)/2;
  return (int) somme;
}
int[] s;
for(int i=0;i<=n;++i) {
  s[i]=sum(i);
}

// pavés
path[] p;
for(int i=1;i<=n;++i) {
  p[i]=scale(i)*unitsquare;
}

// fond
filldraw(scale(s[n],s[n])*unitsquare,white);

// affichage des pavés
for(int i=1;i<=n;++i) {
  if (i%2 == 0) {
    // cas pair
    for(int j=0;j<(i-1)/2;++j) {
      filldraw(shift(s[i-1],i*j)*p[i],pattern("hatch"),black+0.75bp);
      filldraw(shift(i*j,s[i-1])*p[i],pattern("hatchback"),black+0.75bp);
    }
  } else {
    // cas impair
    for(int j=0;j<(i-1)/2;++j) {
      filldraw(shift(s[i-1],i*j)*p[i],gray,black+0.75bp);
      filldraw(shift(i*j,s[i-1])*p[i],gray,black+0.75bp);
    }
    filldraw(shift(i*(i-1)/2,i*(i-1)/2)*p[i],gray,black+0.75bp);
  }
}

// quadrillage
for(int i=0;i<s[n];++i) {
  for (int j=0;j<s[n];++j) {
    draw(shift(i,j)*p[1],currentpen+0.25bp);
  }
}

// blocs
for(int i=1;i<=n;++i) {
  draw(scale(s[i])*p[1],currentpen+1.5bp);
}

Il y a une partie au début qu'on peut simplifier, mais ça donne un exemple de fonction avec un cast explicite real->int.

[OG]

Tu n'utilises pas le motif hatchback défini, dommage parce que je trouve qu'on cligne mieux des yeux si les pavés "verticaux" sont remplis avec hatch et les "horizontaux" avec hatchback. Du coup, avec la superposition, pas besoin du motif crosshatch.

Bref, je propose une variante du code (avec en plus, n qui vaut ce qu'on veut )

Merci pour l'amélioration du code. J'avais tapé le matin pour le jour même tous
ces trucs de somme et une ou deux figures en plus (pour occuper une classe de
seconde dans le cadre d'un parrainage "classe+enseignant+chercheur").
Et comme je code naturellement comme un goret...

Voici ce que cela donne, effectivement hatch et hatchback rendent la figure
encore plus lisible.
O.G.

*** Pour masquer/découvrir le code Asymptote qui a permis de créer la figure, il faut cliquer dessus. ;-) ***

CODE ASYMPTOTE de la figure ci-dessus : Tout sélectionner

 
unitsize(0.5cm);
import patterns;
 
// choisir un entier n
int n=5;
 
// motifs
add("hatch",hatch(2mm));
add("hatchback",hatch(2mm,NW));
 
// sommes des k premiers entiers ( 1<= k <=n )
int sum(int n) {
  real somme=n*(n+1)/2;
  return (int) somme;
}
int[] s;
for(int i=0;i<=n;++i) {
  s[i]=sum(i);
}
 
// pavés
path[] p;
for(int i=1;i<=n;++i) {
  p[i]=scale(i)*unitsquare;
}
 
// fond
filldraw(scale(s[n],s[n])*unitsquare,white);
 
// affichage des pavés
for(int i=1;i<=n;++i) {
  if (i%2 == 0) {
    // cas pair
    for(int j=0;j<(i-1)/2;++j) {
      filldraw(shift(s[i-1],i*j)*p[i],pattern("hatch"),black+0.75bp);
      filldraw(shift(i*j,s[i-1])*p[i],pattern("hatchback"),black+0.75bp);
    }
  } else {
    // cas impair
    for(int j=0;j<(i-1)/2;++j) {
      filldraw(shift(s[i-1],i*j)*p[i],gray,black+0.75bp);
      filldraw(shift(i*j,s[i-1])*p[i],gray,black+0.75bp);
    }
    filldraw(shift(i*(i-1)/2,i*(i-1)/2)*p[i],gray,black+0.75bp);
  }
}
 
// quadrillage
for(int i=0;i<s[n];++i) {
  for (int j=0;j<s[n];++j) {
    draw(shift(i,j)*p[1],currentpen+0.25bp);
  }
}
 
// blocs
for(int i=1;i<=n;++i) {
  draw(scale(s[i])*p[1],currentpen+1.5bp);
}