Dans l'ensemble, c'est juste, euh, une autre astuce en code golf


64

Le but de ce défi est de produire une version ASCII de la couverture de ce superbe album du groupe de rock Pink Floyd.

Les jonctions de briques sont composées de caractères _et |. Les briques ont des caractères de largeur 7 et de hauteur 2, à l'exclusion des jonctions. Donc, l'unité de base, y compris les jonctions, est:

_________
|       |
|       |
_________

Chaque rangée de briques est décalée d'une demi-largeur de brique (4 caractères) par rapport à la rangée précédente:

________________________________________
  |       |       |       |       |     
  |       |       |       |       |     
________________________________________
      |       |       |       |       | 
      |       |       |       |       | 
________________________________________
  |       |       |       |       |     
  |       |       |       |       |     

Le mur est paramétré comme suit. Tous les paramètres sont mesurés en caractères, jonctions comprises:

  1. Décalage horizontal de la première rangée, F. C'est la distance entre la marge gauche et la première jonction verticale de la rangée la plus haute. (Rappelez-vous également le décalage relatif de demi-brique entre les lignes). Ses valeurs possibles sont 0, 1, ..., 7.
  2. Totale largeur , W. Cela inclut les jonctions. Sa valeur est un entier positif.
  3. Totale hauteur , H. Cela inclut les jonctions. Sa valeur est un entier positif.

Le sommet du mur coïncide toujours avec le haut d'une rangée. Le fond peut être déchiqueté (si la hauteur totale n’est pas un multiple de 3). Par exemple, voici la sortie pour 6, 44, 11:

____________________________________________
      |       |       |       |       |     
      |       |       |       |       |     
____________________________________________
  |       |       |       |       |       |     
  |       |       |       |       |       |     
____________________________________________
      |       |       |       |       |     
      |       |       |       |       |     
____________________________________________
  |       |       |       |       |       |     

et une explication visuelle des paramètres:

          F=6
         ......   
     .   ____________________________________________
     .         |       |       |       |       |    
     .         |       |       |       |       |     
     .   ____________________________________________
     .     |       |       |       |       |       | 
H=11 .     |       |       |       |       |       |      
     .   ____________________________________________
     .         |       |       |       |       |     
     .         |       |       |       |       |     
     .   ____________________________________________
     .     |       |       |       |       |       |      

         ............................................
                             W=44

Règles supplémentaires

Vous pouvez fournir un programme ou une fonction.

Le format d'entrée est flexible comme d'habitude. La sortie peut être via STDOUT ou un argument renvoyé par une fonction. Dans ce cas, il peut s'agir d'une chaîne avec des nouvelles lignes ou d'un tableau de chaînes.

Les espaces de fin ou les nouvelles lignes sont autorisés.

Le code le plus court en octets gagne.

Cas de test

Les entrées sont dans l'ordre indiqué ci-dessus, à savoir: décalage horizontal de la première ligne, largeur totale, hauteur totale.

6, 44, 11:
____________________________________________
      |       |       |       |       |     
      |       |       |       |       |     
____________________________________________
  |       |       |       |       |       | 
  |       |       |       |       |       | 
____________________________________________
      |       |       |       |       |     
      |       |       |       |       |     
____________________________________________
  |       |       |       |       |       |     


2, 20, 10:
____________________
  |       |       | 
  |       |       | 
____________________
      |       |     
      |       |     
____________________
  |       |       | 
  |       |       | 
____________________


1, 1, 1:
_


1, 2, 3:
__
 |
 |


3, 80, 21:
________________________________________________________________________________
   |       |       |       |       |       |       |       |       |       |    
   |       |       |       |       |       |       |       |       |       |    
________________________________________________________________________________
       |       |       |       |       |       |       |       |       |       |
       |       |       |       |       |       |       |       |       |       |
________________________________________________________________________________
   |       |       |       |       |       |       |       |       |       |    
   |       |       |       |       |       |       |       |       |       |    
________________________________________________________________________________
       |       |       |       |       |       |       |       |       |       |
       |       |       |       |       |       |       |       |       |       |
________________________________________________________________________________
   |       |       |       |       |       |       |       |       |       |    
   |       |       |       |       |       |       |       |       |       |    
________________________________________________________________________________
       |       |       |       |       |       |       |       |       |       |
       |       |       |       |       |       |       |       |       |       |
________________________________________________________________________________
   |       |       |       |       |       |       |       |       |       |    
   |       |       |       |       |       |       |       |       |       |    

34
Tu m'as eu avec les clickbait dans le hnq
Rohan Jhunjhunwala

2
@RohanJhunjhunwala Cela semble à peu près correct
Insane

4
Merci de faire correspondre le nombre de syllabes dans les paroles ... vous ne croiriez pas à quel point de personnes essaient de créer une chanson et d'obtenir une syllabification incorrecte, cela me rend fou.
Chris Cirefice

1
@ChrisCirefice Haha, merci! Le titre était une partie importante de ce défi
Luis Mendo

Réponses:


17

Pyth, 43 à 27 octets

J'ai besoin de jouer beaucoup au golf ... le score est trop honteux.

AQVE<*H?%N3X*8d+G*4/N3\|\_H

Essayez-le déjà en ligne.

Format d'entrée

6,44
11

Format de sortie

____________________________________________
      |       |       |       |       |     
      |       |       |       |       |     
____________________________________________
  |       |       |       |       |       | 
  |       |       |       |       |       | 
____________________________________________
      |       |       |       |       |     
      |       |       |       |       |     
____________________________________________
  |       |       |       |       |       | 

Explication

AQVE<*H?%N3X*8d+G*4/N3\|\_H   First two inputs as list in Q,
                              third input as E.

AQ                            Assign G to the first item in Q
                              and H to the second item in Q.
  VE                          For N from 0 to E-1:
                   /N3            N floor-div 3.
                                    if N gives a remainder of 3 or 4 or 5
                                    when divided by 6, this will be odd;
                                    otherwise, this will be even.
                 *4               Multiply by 4.
                                    if the above is odd, this will leave
                                    a remainder of 4 when divided by 8;
                                    otherwise, the remainder would be 0.
               +G                 Add G (as an offset).
           X*8d       \|          In the string "        " (*8d),
                                  replace (X) the character with the
                                  index above with "|" (modular indexing,
                                  hence the manipulation above).
       ?%N3             \_        If N%3 is non-zero, use the above;
                                  otherwise, use "_".
     *H                           The above repeated H times.
    <                     H       Take the first H characters of above.
                                  Implicitly print with newline.

On dirait que vous gagnez
wordsforthewise

30

C, 86 85 83 82 octets

3 octets sauvés grâce à Lynn.
1 octet sauvegardé grâce à charlie.

i;f(o,w,h){++w;for(i=0;++i<w*h;)putchar(i%w?i/w%3?i%w+i/w/3*4+~o&7?32:124:95:10);}

1
for(i=0;++i<w*h;)ou si iest fait local (param astuce):for(;++i<w*h;)
charlie

remplacez i;par i=1;et enregistrez un octet supplémentaire dans la boucle for.
xryl669

for(i=1;i<w*h;++i)-> for(i=0;++i<w*h;)enregistre 1
Yay295

@ xryl669 Ce n'est pas valide, les fonctions doivent être réutilisables.
Orlp

@ Yay295 J'ai crédité Charlie avec cela, car il l'a posté 7 heures plus tôt.
Orlp

26

C, 92 octets

b(f,w,h,y,x){for(y=0;y<h;y++,puts(""))for(x=0;x<w;x++)putchar(y%3?(x+y/3*4-f)%8?32:124:95);}

Invoquer comme b(F, W, H).


3
Seulement 92 octets en C? C'est incroyable.
Leaky Nun


13

Perl, 63 octets

#!perl -nl
$y+=print+map$y%3?$_++-$`&7?$":'|':_,($y%6&4)x$&for/ \d+/..$'

En comptant le shebang comme 2, l'entrée est prise à partir de stdin, espace séparé.

Exemple d'utilisation

$ echo 2 20 10 | perl bricks.pl
____________________
  |       |       |
  |       |       |
____________________
      |       |
      |       |
____________________
  |       |       |
  |       |       |
____________________

11

Haskell, 83 octets

q s="_":[s,s]
(f!w)h=take h$cycle$take w.drop(7-f).cycle<$>q"       |"++q"   |    "

Ceci définit une fonction infixe ternaire !qui renvoie une liste de chaînes. Exemple d'utilisation:

*Main> putStrLn $ unlines $ (3!14) 7
______________
   |       |  
   |       |  
______________
       |      
       |      
______________

Comment ça fonctionne:

            q"       |"++q"   |    "  -- build a list of 6 strings
                                      --   1:     "_"
                                      --   2:     "       |"
                                      --   3:     "       |"
                                      --   4:     "_"
                                      --   5:     "   |    "
                                      --   6:     "   |    "
         <$>                          -- for each of the strings
     take w.drop(7-f).cycle           -- repeat infinitely, drop the first 7-f chars
                                      --    and take the next w chars
  cycle                               -- infinitely repeat the resulting list
take h                                -- and take the first h elements

1
Des réponses comme celle-ci me donnent envie d'apprendre cette langue.
GuitarPicker

3
J'ai pensé à Haskell en lisant la description du problème. "Répéter infiniment" est une fonctionnalité vraiment chouette.
DLosc

10

JavaScript (ES6), 96 95 octets

g=
(f,w,h)=>[...Array(h)].map((_,i)=>(i%3?`       |`:`_`).repeat(w+7).substr(f^7^i%6&4,w)).join`
`
;
<div onchange=o.textContent=g(f.value,w.value,+h.value)><input id=f type=number min=0 max=7 placeholder=Offset><input id=w type=number min=0 placeholder=Width><input id=h type=number min=0 placeholder=Height></div><pre id=o>

Explanation: Crée une chaîne composée du |motif répétitif de 7 espaces ou plus ou de _s répétés , mais au moins suffisamment longue pour pouvoir extraire les wcaractères requis pour chaque ligne. Les trois premières lignes commencent à la position f^7, puis les trois lignes suivantes à la position f^3. Pour ce faire, je permute le bit 2 de ftoutes les trois lignes en utilisant le bit 2 opposé sur les deux dernières lignes de chaque bloc de 6 pour une économie de 1. octet.


7

MATL, 42 36 33 octets

:-Q'_ | |'[DClCl]Y"8et4YShwi:3$)!

Format d'entrée est: nCols, offset,nRows

Essayez-le en ligne

L’approche consiste ici à créer un "modèle" dans lequel nous indexons en utilisant les index de ligne ( [1 2 ... nRows]) et les index de colonne décalés de la première entrée ( [1 2 ... nCols] - shift). Grâce à l'indexation modulaire de MATL, il en résulte automatiquement une sortie en mosaïque. En passant, pour économiser de l’espace, techniquement, je travaille avec une version transposée du modèle, puis je prends une transpose ( !) à la fin.

Le modèle est le suivant:

________
       |
       |
________
  |     
  |     

1
Belle utilisation du codage par longueur de plage pour générer le modèle
Luis Mendo

6

Python 2, 93 88 octets

Le deuxième niveau d'indentation est un onglet Sauvegarde de quelques octets grâce à Leaky Nun et à quelques modifications propres, également le décalage correct:

def f(F,W,H):
 for h in range(H):print["_"*W,((("|"+7*" ")*W)[8-F+h%6/3*4:])[:W]][h%3>0]

code précédent:

def f(F,W,H,x="|"+7*" "):
 for h in range(H):
    print ["_"*W,(x[F+4*(h%6>3):]+x*W)[:W]][h%3>0]

Même longueur que lambda sans nom:

lambda F,W,H,x="|"+7*" ":"\n".join(["_"*W,(x[F+4*(h%6>3):]+x*W)[:W]][h%3>0]for h in range(H))

F,W,H=input()
Leaky Nun

supprimer l'espace aprèsprint
Leaky Nun

utiliser h/3%2*4ou h%6/3*4au lieu de4*(h%6>3)
Leaky Nun

Vous n'avez pas besoin du deuxième niveau d'indentation. Mettez simplement la printdéclaration sur la même ligne que la fordéclaration
Leaky Nun

"| "est plus court que ("|"+7*" ")si je compte correctement
Leaky Nun

6

QBasic, 121 109 octets

(Testé sur QB64)

Merci à @DLosc pour avoir joué mon IFénoncé avec un équivalent mathématique. Cela valait 12 octets.

Méthode générale:

Boucle à travers chaque cellule une à la fois et de déterminer si elle doit être _, ou en |fonction de son emplacement. MODles instructions et la logique booléenne sont utilisées pour déterminer les limites des briques et leur degré d'échelonnement.

Code:

INPUT F,W,H
FOR y=0TO H-1:FOR x=0TO W-1
?CHR$((y MOD 3>0)*(((x-(y MOD 6>3)*4)MOD 8=F)*92+63)+95);
NEXT:?:NEXT

Note d'utilisation:

QBasic s'attend à ce que les entrées soient des nombres séparés par des virgules.


1
Utiliser math au lieu de IF/ THENajoute encore plus de parenthèses mais enregistre 12 octets:?CHR$((y MOD 3>0)*(((x-(y MOD 6>3)*4)MOD 8=F)*92+63)+95);
DLosc

Merci pour le commentaire. À l'arrière de ma tête, j'avais envisagé d'explorer les mathématiques, mais je ne l'ai pas fait. J'ai fait quelque chose de similaire pour colorer une image dans une soumission récente , mais l'implémentation que j'ai utilisée n'avait pas d'opérateur MOD.
GuitarPicker

5

Java, 149 , 147 , 146 , 143 octets

Golfé:

String f(int o,int w,int h){String s="";for(int y=0,x;y<h;++y){for(x=0;x<w;++x){s+=y%3>0?(x-o+(y-1)/3%2*4)%8==0?'|':' ':'_';}s+='\n';}return s;}

Ungolfed:

public class AllInAllItsJustUhAnotherTrickInCodeGolf {

  public static void main(String[] args) {
    int offset = 6;
    int width = 44;
    int height = 11;
    System.out.println(new AllInAllItsJustUhAnotherTrickInCodeGolf()
        .f(offset, width, height));
  }

  // Begin golf
  String f(int o, int w, int h) {
    String s = "";
    for (int y = 0, x; y < h; ++y) {
      for (x = 0; x < w; ++x) {
        s += y % 3 > 0 ? (x - o + (y - 1) / 3 % 2 * 4) % 8 == 0 ? '|' : ' ' : '_';
      }
      s += '\n';
    }
    return s;
  }
  // End golf

}

1
Peut-être pourriez-vous changer l’ordre du ternaire en comparant > 0ce qui pourrait sauver deux caractères. Et bien sûr, vous pouvez combiner les déclarations à int y=0,x.
Frozn

Comme le dit Frozn , vous pouvez supprimer int avant xet utiliser int y=0,xdans la première boucle for au lieu de sauvegarder 2 octets. En outre, vous pouvez actuellement changer y%3==0pour y%3<1. (Ce n'est pas possible pour ...%8==0à ...&8<1bien, car votre opération pourrait renvoyer un nombre négatif.)
Kevin Cruijssen

Fait et fait. Vous avez raison, ce deuxième modulo peut renvoyer négatif et il l’a été lors du débogage lorsque j’ai écrit cette fonction.

1
Vous ne savez pas comment nous avons manqué cela, mais vous pouvez supprimer les espaces de vos paramètres pour -2 octets. Sinon, vous pouvez également utiliser int...ocomme paramètre et modifier wto o[1], hto o[2]et oto o[0]-3 octets.
Kevin Cruijssen

4

Rubis, 72 66 octets

->f,w,h{h.times{|i|puts i%3<1??_*w:((?|+' '*7)*w)[8-f+i%6/4*4,w]}}

Merci @Value Ink pour 6 octets!

Multiplication et découpage de chaînes simples.

Fonctionne dans Ruby 2.3.0 (la version 2.1 d'Ideone renvoyait une erreur de syntaxe).


2
Utilisez i%6/4*4au lieu de (i%6>3?4:0)et utilisez ?_au lieu de '_', ?|au lieu de '|'.
Valeur d'encre

Je vous remercie. J'ai oublié le tour de mon personnage ?, et la partie "maths" est vraiment impressionnante!
Leibrug

1
Je pense que ((' '*7+?|)*w)[f^7^i%6&4,w]vous sauve deux octets.
Neil

Merci @Neil. Je vais modifier le code ... dès que je comprendrai le fonctionnement de votre suggestion :)
Leibrug

4

Julia: 150 128 116 108 107 octets

# in codegolf.jl
r=repmat;b=r([' '],6,8);b[[1,4],:]='_';b[[2,3,23,24]]='|';b=r(b,h,w)[1:h,o+=1:o+w];b[:,end]=10;print(b'...)

courir avec des arguments: julia -e 'o=2;h=18;w=40;include("codegolf.jl")'

Si vous sentez que téléphoner depuis bash est une triche et que vous voulez une fonction dans l'interpréteur, la version de la fonction est de 117 octets :)

f(o,h,w)=(r=repmat;b=r([' '],6,8);b[[1,4],:]='_';b[[2,3,23,24]]='|';b=r(b,h,w)[1:h,o+=1:o+w];b[:,end]=10;print(b'...))

démo

(Merci, @ glen-o pour le conseil supplémentaire permettant d'économiser des octets!)


Bienvenue chez PPCG! Ravi de vous voir aussi ici!
Luis Mendo

Notez que les entrées doivent être prises explicitement, c'est-à-dire que vous avez besoin d'une sorte d'instruction d'entrée pour ces trois variables. Ou vous pouvez utiliser une fonction qui les prend comme arguments et affiche ou affiche le résultat. Lorsque vous avez terminé, vous pouvez publier une démonstration en ligne avec Essayez-le en ligne!
Luis Mendo


ah Oui je l'ai fait! : p
Tasos Papastylianou

1
Vous pouvez enregistrer quelques caractères en utilisant repmat au lieu de uns ( repmat([32],6,8)), puis en renommant repmat pour supprimer un autre caractère ( g=repmat;b=g([32],6,8)et plus tard b=g(b,h,w)[1:h,o+1:o+w+1]). Puis remplacez reinterpretpar map. À mon compte, vous économiserez 9 octets entre ces modifications.
Glen O

3

JavaScript, 172 168 165 157 147 147 142 137 octets

(O,W,H)=>{t='_'.repeat(W),x='|       '.repeat(W),f=t+`
`;for(i=0;++i<H;)f+=(!(i%3)?t:(i%6)>3?x.substr(O,W):x.substr(8-O,W))+`
`;return f}

N = (O,W,H)=>{t='_'.repeat(W),x='|       '.repeat(W),f=t+`
`;for(i=0;++i<H;)f+=(!(i%3)?t:(i%6)>3?x.substr(O,W):x.substr(8-O,W))+`
`;return f}

let test_data = [[6,44,11],
                 [2,20,10],
                 [1,1,1],
                 [1,2,3],
                 [3,80,21]];

for (test of test_data)
    console.log(N(...test));


Pourquoi ne pas utiliser s.repeat(w)au lieu de Array(w).fill(s).join``?
Neil

@ Neil: Bonne idée, mais j'ai pensé à quelque chose de mieux.
Yay295

et ensuite réalisé que votre solution est meilleure que je pensais. Merci!
Yay295

3

Dyalog APL, 29 octets

↑⎕⍴⎕⍴¨a,4⌽¨a←'_',2⍴⊂⌽⎕⌽¯8↑'|'

essais: 6 44 11, 2 20 10, 1 1 1, 1 2 3, 3 80 21

est évalué l'entrée; comme l'expression exécute de droite à gauche, il demande F, Wet Hdans cet ordre

¯8↑'|' est ' |'

⎕⌽ est une rotation, elle coupe les caractères F de l'avant et les met à la fin de la chaîne

l'autre moyen inverse

'_',2⍴⊂ crée un 3-tuple de '_' suivi de deux copies séparées de la chaîne jusqu'à présent

a,4⌽¨a← ajouter les 4 rotations de tout jusqu'à présent, nous nous retrouvons avec un 6 tuple

⎕⍴¨ remodeler chaque élément à la largeur

⎕⍴ remodeler à la hauteur

mélanger le vecteur de vecteurs dans une matrice


2

En fait , 44 43 40 octets

C'est un portage réel de l'algorithme dans la réponse JS de Neil . Les suggestions de golf sont les bienvenues. Essayez-le en ligne!

╗╝r⌠;6(%4&╜7^^╛'|7" "*+*t╛@H╛'_*3(%YI⌡Mi

Ungolfing:

          Takes implicit input in the order h, w, f.
╗╝        Save f to register 0. Save w to register 1.
r⌠...⌡M   Map over range [0..h-1]. Call this variable i.
  ;         Duplicate i
  6(%       i%6...
  4&        ...&4
  ╜7^^      ...^i^7. Call it c.
  ╛         Push w.
  '|7" "*+  The string "       |"
  *t╛@H     (("       |" * w)[c:])[:w]
  ╛'_*      Push "_" * w
  3(%       Push 3, move duplicate i to TOS, mod.
  YI        If not i%3, take "_"*w, else (("       |" * w)[c:])[:w]
            Function ends here.
i         Flatten the resulting list and print the bricks implicitly.


1

Octave 80 76 octets

% in file codegolf.m
c(6,8)=0;c([1,4],:)=63;c([2,3,23,24])=92;char(repmat(c+32,h,w)(1:h,o+1:o+w))

à partir du terminal: octave --eval "o=2;h=18;w=44; codegolf"

(alternativement, si vous pensez que l'appel du terminal est en train de tricher: p alors une implémentation de fonction anonyme prend 86 octets :)

c(6,8)=0;c([1,4],:)=63;c([2,3,23,24])=92;f=@(o,h,w)char(repmat(c+32,h,w)(1:h,o+1:o+w))

Appeler f(2,18,44)à l'interprète d'octave.


1

Bash + Sed, 411 395 381 370 octets:

F=`printf '_%.s' $(eval echo {1..$2})`;V="       |";(($[($2-$1)/8]>0))&&L=`printf "$V%.s" $(eval echo {1..$[($2-$1)/8]})`||L=;Z=`printf "%$1.s|%s\n" e "$L"`;I=$[($2-(${#Z}-4))/8];(($I>0))&&W=`printf "$V%.s" $(eval echo {1..$I})`||W=;J=${Z:4}$W;for i in `eval echo {1..$[$3/3+1]}`;{ (($[$i%2]<1))&&O+="$F\n$J\n$J\n"||O+="$F\n$Z\n$Z\n";};echo "`echo -e "$O"|sed -n 1,$3p`"

Eh bien, voici ma toute première réponse dans Bash, ou n'importe quel langage de script shell. C'est aussi de loin la réponse la plus longue ici. Prend une séquence d'arguments de ligne de commande séparés par des espaces dans le format Offset Width Height. Cela peut probablement être beaucoup plus court qu’il ne l’est actuellement, alors tous les trucs et astuces pour jouer au golf plus sont appréciés.


1

Delphi / Object Pascal, 305 , 302 , 292 octets

Programme console complet qui lit 3 paramètres.

uses SySutils,Math;var i,q,o,w,h:byte;begin o:=StrToInt(paramstr(1));w:=StrToInt(paramstr(2));h:=StrToInt(paramstr(3));for q:=0to h-1do begin for i:=1to w do if q mod 3=0then Write('_')else if IfThen(Odd(q div 3),((i+o)mod 8),((i-o)mod 8))=1then Write('|')else Write(' ');Writeln('');end end.

non-golfé

uses
  SySutils,
  Math;
var
  i,q,o,w,h:byte;
begin
  o:=StrToInt(paramstr(1));
  w:=StrToInt(paramstr(2));
  h:=StrToInt(paramstr(3));

  for q := 0 to h-1 do
  begin
    for i := 1 to w do
      if q mod 3 = 0  then
        Write('_')
      else
        if IfThen(Odd(q div 3),((i+o)mod 8),((i-o)mod 8)) = 1 then
          Write('|')
        else Write(' ');
    Writeln('');
  end
end.

Malheureusement, Delphi n’a pas d’opérateur ternaire et c’est un langage assez prolixe.

cas de test

D:\Test\CodeGolfWall\Win32\Debug>Project1.exe 2 20 10
____________________
  |       |       |
  |       |       |
____________________
      |       |
      |       |
____________________
  |       |       |
  |       |       |
____________________

D:\Test\CodeGolfWall\Win32\Debug>Project1.exe 6 44 11
____________________________________________
      |       |       |       |       |
      |       |       |       |       |
____________________________________________
  |       |       |       |       |       |
  |       |       |       |       |       |
____________________________________________
      |       |       |       |       |
      |       |       |       |       |
____________________________________________
  |       |       |       |       |       |

Éditer: Pourrait supprimer 3 octets en utilisant octet comme type pour toutes les variables.

Edit 2: Et les applications de console n'ont pas besoin de la déclaration de programme, -10

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.