Dessiner un damier ASCII

25

Sommaire

Inspiré par la popularité récente des défis artistiques ASCII, le but de ce défi est de dessiner un damier ASCII, comme celui sur lequel les échecs peuvent être joués.

Écrivez un programme qui prend un entier positif ncomme argument, dans stdinou comme entrée utilisateur, et sortez un damier avec nx ncarrés, avec une bordure de 1 caractère d'épaisseur.

Chaque carré doit contenir 2 x 2 caractères. Les carrés doivent suivre le modèle alternant blanc-noir normal (blanc en premier, comme dans le coin supérieur gauche) d'un damier. Les carrés blancs doivent être constitués de caractères espace ( ) et les carrés noirs doivent être constitués de caractères dièse ( #).

La bordure doit être faite de tirets ( -) avec un plus ( +) sur la bordure ou le point perpendiculaire d'un carré.

Contribution

Entier positif représentant le nombre de carrés (dimensions en carrés) à dessiner dans le damier, chaque carré étant 2x2 caractères.

Exemples de résultats

n=2

+--+--+
|  |##|
|  |##|
+--+--+
|##|  |
|##|  |
+--+--+

n=3

+--+--+--+
|  |##|  |
|  |##|  |
+--+--+--+
|##|  |##|
|##|  |##|
+--+--+--+
|  |##|  |
|  |##|  |
+--+--+--+

n=4

+--+--+--+--+
|  |##|  |##|
|  |##|  |##|
+--+--+--+--+
|##|  |##|  |
|##|  |##|  |
+--+--+--+--+
|  |##|  |##|
|  |##|  |##|
+--+--+--+--+
|##|  |##|  |
|##|  |##|  |
+--+--+--+--+

... etc.


Remarques

  • Les espaces de fin et les nouvelles lignes sont acceptables.
  • Vous pouvez écrire soit un programme entier soit une fonction.
  • Pas d'espaces principaux.
  • Votre programme devrait afficher des résultats corrects pour n = 15.
  • Pour les langues ésotériques moins connues et similaires, fournissez un lien vers la langue.
  • n=0devrait produire +. (facultatif, mais fortement recommandé et encouragé.)
  • Le code le plus court en octets gagne, car il s'agit du code golf.
kdragon
la source
2
Bienvenue dans Programmation d'énigmes et Code Golf! Beau travail ici, surtout pour votre premier défi. J'ai hâte de voir plus de vos trucs.
Alex A.
Je suppose que "votre programme devrait afficher des résultats corrects pour n = 15". signifie "jusqu'à n = 15"?
John Dvorak
"Votre programme devrait afficher des résultats corrects pour n = 10." signifie que si votre programme ne peut pas afficher correctement jusqu'à n = 15, il ne doit pas être publié. Mais cela ne signifie pas que vous devez exploiter / abuser de cela et écrire un programme qui ne peut aller que jusqu'à n = 15.
kdragon
J'upvote réponses travail testées, même si elles ne produisent pas +pour n=0.
kdragon
Désolé, je n'ai jamais accepté le gagnant. J'accepte maintenant.
kdragon

Réponses:

16

J, 24 octets

Une fonction anonyme:

2 2&$&.>@(' #'{~2|+/~@i.)

Usage:

   f =: 2 2&$&.>@(' #'{~2|+/~@i.)
   f 4
+--+--+--+--+
|  |##|  |##|
|  |##|  |##|
+--+--+--+--+
|##|  |##|  |
|##|  |##|  |
+--+--+--+--+
|  |##|  |##|
|  |##|  |##|
+--+--+--+--+
|##|  |##|  |
|##|  |##|  |
+--+--+--+--+
Lynn
la source
1
&.>est un plus court que each. Il convient de noter qu'il ne fonctionne que s'il BoxFormest défini sur ASCII.
randomra
10

Python 2, 79

N=3*input()+1
for i in range(N):print('+||- #- #+||-# -# '*N)[3**i%7/2%3:3*N:3]

Pour chaque ligne, sélectionne l'un des modèles

+--+--+--+--+--+
|  |##|  |##|  |
|##|  |##|  |##|

et en imprime des 3*n+1caractères. Le motif est choisi en répétant ses 6 premiers caractères, sélectionnés avec l'astuce d'entrelacement de chaîne, qui sert également à extraire un extrait de la bonne longueur.

Le motif correct est sélectionné sur la base de la valeur de l'index de ligne imodulo 6 par une expression arithmétique 3**i%7/2%3qui donne le motif répétitif [0,1,1,0,2,2]. Je l'ai trouvé en utilisant le fait qu'il x**i%7a un point 6, puis en essayant différentes valeurs xet différents post-traitements pour obtenir le bon modèle.

xnor
la source
9

Pyth, 37

VJh*3Qsm@?+\|*2@" #"+/N3/d3%N3"+--"dJ

Plutôt piraté ensemble, mais bref.

Manifestation.

isaacg
la source
9

CJam, 43 42 octets

ri3*)_2m*{_3f%:!2b\3f/:+2%(e|"#|-+ "=}%/N*

Essayez-le en ligne .

Chaque coordonnée est mappée à un caractère, par exemple le coin supérieur gauche est (0, 0) -> "+". Plus précisément, nous calculons

[(y%3 == 0)*2 + (x%3 == 0)] or [(x//3 + y//3) % 2 - 1]

et indexez la chaîne en "#|-+ "conséquence.

Sp3000
la source
6

Rétine , 106 octets

1
$_0$_x
1(?=1*0)
+--
1(?=1*x)
s
(0s.*?0)s
$1o
(s\D*?)s
$1o
s
|  
o
|##
\D*?x
$0$0
0
+n
x
|n
(.*?n).*
$0$1

Prend la contribution comme unaire (sur la base de cette méta-discussion ).

Chaque ligne doit aller dans son propre fichier et ndoit être remplacée par un retour à la ligne dans les fichiers. Ceci n'est pas pratique, mais vous pouvez exécuter le code tel quel, en un seul fichier, avec l' -sindicateur, en conservant les nmarqueurs. nSi vous le souhaitez, vous pouvez changer les 's en sauts de ligne dans la sortie pour plus de lisibilité. Par exemple:

> echo -n 111|retina -s checkerboard|tr n '\n'
+--+--+--+
|  |##|  |
|  |##|  |
+--+--+--+
|##|  |##|
|##|  |##|
+--+--+--+
|  |##|  |
|  |##|  |
+--+--+--+

Plus de golf et quelques explications viennent plus tard.

randomra
la source
4

JavaScript (ES6), 117

n=>Array(n*3+1).fill("+--".repeat(n)+"+").map((v,i)=>v.replace(/./g,(k,x)=>i%3?"|  |##|  "[x%6+(i%6>2)*3]:k)).join`
`

Fragment:

<input type="range" min=2 max=15 step=1 value=1 id="i" oninput="o.textContent=f(this.value)"><pre id="o"></pre><script>function f(n){ return Array.apply(0,Array(n*3+1)).map(function(){return "+--".repeat(n)+"+"}).map(function(v,i){ return v.replace(/./g,function(k,x) { return i%3?"|  |##|  "[x%6+(i%6>2)*3]:k}) }).join("\n") };o.textContent=f(2)</script>

Fonction anonyme. Commence par un tableau complet de +--+--+--...lignes, et sur les lignes appropriées, remplace le +pour |et -pour ou #selon le cas.

L'expression qui décide du caractère de remplacement "| |##| "[x%6+(i%6>2)*3], pourrait probablement être jouée plus loin, mais j'ai trouvé que l'utilisation d'une chaîne plus longue et redondante enregistre plus de caractères qu'un calcul complexe.

absides
la source
Bonne utilisation ES6! L'effet du curseur dans l'extrait est un bel ajout. Pourriez-vous fournir une explication et une version non golfée?
kdragon
3

CoffeeScript avec ES6, 106 octets

f=(n,y=z='+--'[r='repeat'](n)+'+\n')->y+=('|##|  '[r](n).substr(i%2*3,n*3)+'|\n')[r](2)+z for i in[1..n];y

JavaScript (ES6), 111 octets

Les sauts de ligne sont significatifs et comptent pour 1 octet chacun.

Le retour explicite l'a rendu un peu plus long:

f=n=>{for(i=0,y=z='+--'[r='repeat'](n)+`+
`;i<n;)y+=('|##|  '[r](n).substr(++i%2*3,n*3)+`|
`)[r](2)+z;return y}

Démo

Au moment de la rédaction de cet article, Firefox est le seul navigateur majeur compatible avec ES6.

f=n=>{for(i=0,y=z='+--'[r='repeat'](n)+`+
`;i<n;)y+=('|##|  '[r](n).substr(++i%2*3,n*3)+`|
`)[r](2)+z;return y}

// Demonstration related things
document.getElementById('O').innerHTML = f(document.getElementById('n').value);

document.getElementById('n').addEventListener('change', function () {
  document.getElementById('O').innerHTML = f(this.value);
});
<p><input id=n type=number min=0 step=1 value=6></p>
<pre><output id=O></output></pre>

rink.attendant.6
la source
3

Python 3, 114 108 100

def f(n):
 for i in range(3*n+1):print(("|##|  "*n+"|")[::i//3%2*2-1][:3*n+1]if i%3 else"+--"*n+"+")


Solutions précédentes

108

def f(n):
 for i in range(3*n+1):
  a=("|##|  "*n+"|")[::i//3%2*2-1][:3*n+1];print(a if i%3 else"+--"*n+"+")

114

def f(n):a="+--"*n+"+\n";b="|  |##"*n+"|";print(a+a.join(([(b[:3*n+1]+"\n")*2,(b[::-1][:3*n+1]+"\n")*2]*n)[:n])+a)

118 (non soumis)

def f(n):
 for i in range(3*n+1):print((("|##|  "*n)[:3*n+1]if i//3%2 else("|  |##"*n)[:3*n+1])if i%3 else"+--"*n+"+")
monopole
la source
3

CJam, 46 octets

li3*)_2m*[{_3f/2f%:=\3f%:g+2b"+-|#+-| "=}/]/N*

Essayez-le en ligne

Eh bien, j'espérais avoir au moins une solution originale (normalement je ne regarde pas les autres réponses avant de travailler par moi-même). Il s'avère que @ Sp3000 avait déjà fait quelque chose de très similaire, mais en mieux. Mais puisque j'ai déjà fait le travail, j'ai pensé que je le publierais quand même.

Explication:

li    Get input n.
3*)   Calculate 3*n+1, which is the total width/height.
_     Copy size. We'll need it at the end to insert the newlines.
2m*   Calculate cartesian power with 2. This enumerates all coordinate pairs.
[     Wrap characters in array for split operation at the end.
  {     Loop over all coordinate pairs.
    _     Copy coordinate pair.
    3f/   Divide coordinates by 3.
    2f%   Modulo 2. This characterizes even/odd squares.
    :=    Compare the two coordinates. This gives 0/1 for white/black squares.
    \3f%  Grab second copy of coordinates, and calculate modulo 3.
    :g    Sign. This gives 0 for grid lines, 1 for interior of squares.
    +     Concatenate the two results. We now have a 3 bit code.
    2b    Convert the 3 bits to a number in range 0..7.
    "+-|#+-| "
          Lookup table to convert 0..7 number to character.
    =     Lookup character.
  }/    End loop over coordinate pairs.
]     End wrapping characters.
/     Split character array into lines.
N*    And join them with newlines.
Reto Koradi
la source
2

HackVM , 158 octets

Certainement pas un gagnant, mais cela ressemblait à un beau défi à faire dans HVM.

Placez la taille dans la première cellule mémoire et utilisez le code suivant:

77*1+c0<0^84*1+?1-11<-1>99*85++0^cc77*1+c066*5+-g!0<0^45*2+?1-95*0^0^2-PPP064*-6-gd95*2-P25*P$1<2>555**1-P0<0^76*6-?1-12<-2>2<3*48*+0^PP555**1-P076*2+-gd25*P$

Remarque: Le code doit être exactement sur une seule ligne pour fonctionner.

Explication:

Call PLUSHDASHLINE
77*2+c

Read the cell and skip if done
0<0^84*1+?1-

  Flip row parity
  11<-1>

  Call NORMALLINE twice
  99*85++0^cc

  Call PLUSHDASHLINE
  77*1+c

Jump back to start of loop
066*5+-g!


DEFINE_PLUSDASHLINE
0<0^45*2+?1-95*0^0^2-PPP064*-6-gd95*2-P25*P$

DEFINE_NORMALLINE
1<2>555**1-P0<0^76*6-?1-12<-2>2<3*48*+0^PP555**1-P076*2+-gd25*P$

Le code appelle 2 fonctions PLUSHDASHLINEet NORMALLINEmaintient un état global pour les parités (c'est-à-dire s'il faut mettre un ' 'ou un '#'dans une cellule).

Explication pour PLUSDASHLINE:

Repeat N times
0<0^45*2+?1-

  Print "+--"
  95*0^0^2-PPP

End Repeat
064*-6-g

Print "+"
d95*2-P

Print "\n"
25*P

Return
$

Explication pour NORMALLINE:

Copy Parity into Cell 2
1<2>

Print '|'
555**1-P

Repeat N times
0<0^76*6-?1-

  Flip Cell 2 (i.e. Flip Column Parity)
  12<-2>

  Calculate ' ' or '#' based upon parity
  2<3*48*+0^

  Print it twice
  PP

  Print '|'
  555**1-P

End Repeat
076*2+-g

Print "\n"
d25*P

Return
$

J'apprécierais que quelqu'un donne des conseils pour l'améliorer encore :)

Jay Bosamiya
la source
2

Python 2, 98

n=input()
f=lambda a,b,s:s+s.join(([a*2,b*2]*n)[:n])+s+'\n'
print f(f(*' #|'),f(*'# |'),f(*'--+'))

Pas le chemin le plus court, mais une méthode amusante. La fonction fprend deux chaînes a,bet un séparateur set entrelace ses arguments comme saasbbsaasbbsaas. Les rangées de la planche sont créées sous cette forme avec leurs caractères respectifs, puis sont elles-mêmes entrelacées de cette façon pour produire le résultat.

xnor
la source
Cela produit une sortie non valide pour n=0. La majorité des solutions (qui seront acceptées) produisent "+". Cette solution produit "++ (newline) ++", à l'exclusion des 2 nouvelles lignes de fin normales (ce qui est autorisé).
kdragon
@DragonGuy Le problème indique que l'entrée est un entier positif.
xnor
Mais il devrait y avoir un repli pour au moins 0. Les replis négatifs ne sont pas requis. Il n'y aura pas de règle pour les nombres inférieurs à 0. Cette solution semble donner "++ (newline) ++" pour tout ce qui est inférieur à 1.
kdragon
@DragonGuy Lorsque vous spécifiez les exigences d'entrée, cela signifie que l'entrée est garantie pour répondre à ces exigences, et peut agir arbitrairement quand ce n'est pas le cas. Je remarque que vous avez modifié la question pour ajouter "n = 0 devrait produire +" après que cela a été publié, mais il est fortement déconseillé de modifier les règles une fois que les réponses sont entrées .
xnor
Je pensais à cette règle (lisez beaucoup de questions avant) avant de modifier la question, mais comme cela n'allait pas affecter la grande majorité des réponses, je ne pensais pas que ce serait un problème. Question modifiée pour plus de clarté et rendre cette option facultative.
kdragon
2

Ruby: 83 caractères

f=->n{puts d=?++'--+'*n,(0...n).map{|i|[?|+'%2s|'*n%(['','##',''][i%2,2]*n)]*2<<d}}

Exemple d'exécution:

irb(main):001:0> f=->n{puts d=?++'--+'*n,(0...n).map{|i|[?|+'%2s|'*n%(['','##',''][i%2,2]*n)]*2<<d}}
=> #<Proc:0x000000007c51a0@(irb):1 (lambda)>

irb(main):002:0> f[0]
+
=> nil

irb(main):003:0> f[1]
+--+
|  |
|  |
+--+
=> nil

irb(main):004:0> f[2]
+--+--+
|  |##|
|  |##|
+--+--+
|##|  |
|##|  |
+--+--+
=> nil

irb(main):005:0> f[3]
+--+--+--+
|  |##|  |
|  |##|  |
+--+--+--+
|##|  |##|
|##|  |##|
+--+--+--+
|  |##|  |
|  |##|  |
+--+--+--+
=> nil
homme au travail
la source
2

Rubis, 87

->n{a=[b="+--",c="|  |##",c,b,d="|##|  ",d]
0.upto(n*3){|i|puts"".ljust(n*3+1,a[i%6])}}

Il s'agit d'une fonction anonyme. Appelez ça comme ça (toutes les possibilités de 0 à 5)

f=->n{a=[b="+--",c="|  |##",c,b,d="|##|  ",d]
0.upto(n*3){|i|puts"".ljust(n*3+1,a[i%6])}}

6.times{|j|f.call(j)}

Il utilise la ljustméthode sur une chaîne vide. Ruby permet de spécifier une chaîne de remplissage pour la justification, nous utilisons donc l' ljustune des trois chaînes de remplissage possibles b,c,dpar tableau a, ordonnée comme bccbdd.

Level River St
la source
1

Julia, 124 octets

n->(t="+--"^n*"+";a="|  ";b="|##";m=n÷2;c=n%2>0;p=println;p(t);for i=1:n p(((i%2<1?(b*a)^m*b^c:(a*b)^m*a^c)*"|\n")^2*t)end)

Cela crée une fonction sans nom qui accepte un entier et s'imprime sur stdout.

Non golfé + explication:

function f(n)
    # Define the portions of the board
    t = "+--"^n * "+"
    a = "|  "
    b = "|##"

    # There will be n÷2 repeated a*b or b*a per line
    m = n ÷ 2

    # If n is odd, there will be an extra a or b
    c = n % 2 != 0

    # Print the top
    println(t)

    # Print each horizontal section of the board
    for i = 1:n
        # In even numbered sections, b precedes a
        j = (i % 2 == 0 ? (b*a)^m * b^c : (a*b)^m * a^c) * "|\n"
        println(j^2 * t)
    end
end
Alex A.
la source
1

Javascript, ES6 149

n=>(r="+--".repeat(n)+"+",[...r].map((_,i)=>i%3?(x=i%6&&i%6<3?" ":"#",[...r].map((_,e)=>e%3?e%6&&e%6<3?x:"#"==x?" ":"#":"|").join('')):r).join('\n'))

Plutôt amusant à écrire même si c'est un peu long

Fonctionne sur Firefox

1 - Console ouverte

2 - Tapez ce qui suit

console.log((n=>(r="+--".repeat(n)+"+",[...r].map((_,i)=>i%3?(x=i%6&&i%6<3?" ":"#",[...r].map((_,e)=>e%3?e%6&&e%6<3?x:"#"==x?" ":"#":"|").join('')):r).join('\n')))(15));

Sortie (n = 15):

+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
Afonso Matos
la source
Pourriez-vous ajouter un extrait comme les autres solutions ES6? Cela faciliterait les tests.
kdragon
J'allais modifier mon commentaire dans les 5 minutes, mais ma connexion était défectueuse. Pourriez-vous ajouter un extrait comme les autres solutions ES6? Cela faciliterait les tests. Pour un pro JavaScript et un noob ES6, cela ne fonctionne pas dans le Scratchpad de Firefox.
kdragon
@DragonGuy Done, voyez si cela fonctionne pour vous.
Afonso Matos
1
À la fin, vous pouvez toujours enregistrer trois octets en remplaçant join('\n')par join` `, où l'espace que j'ai écrit indique un nouveau caractère de ligne réel.
Chiru
1

Haskell, 99

Ceci est partiellement inspiré par la réponse précédente de Haskell par catgocat ; J'ai écrit ma propre version, puis je l'ai regardée, puis j'en ai écrit une autre. Je joue selon les mêmes règles - l'entrée est un argument, mais la sortie est standard. (S'il peut s'agir d'une fonction pure, soustrayez 7 caractères putStr$.)

f n=putStr$unlines$t$map t$y[a,b,b,a,c,c]where t=take(n*3+1)
a=y"+--"
b=y"|  |##"
c=drop 3b
y=cycle

Nous utilisons tpour prendre une région de 3 n + 1 caractères à partir d'un damier infini construit en utilisant cycle, et c'est tout. L'idée principale que j'ai tirée de l'autre réponse est celle de rassembler les motifs des cellules de bordure et de vérificateur en chaînes.

Ma première version (140 caractères) a utilisé la stratégie de calcul du caractère à chaque point, ce qui pourrait être mieux pour un problème plus complexe que celui-ci.

f n=putStr$unlines$map(\y->map(g y)r)r where r=[0..n*3]
g y x=s(s '+'y '|')x$s '-'y$cycle" #"!!(x`div`3+y`div`3)
s c i d|i`mod`3==0=c|True=d
Kevin Reid
la source
Je suis heureux que votre inspiration ait conduit à une réponse aussi intelligente :)
Afonso Matos
J'obtiens 84 octets lors de l'écriture dans un fichier avec cat <<EOF > sol1.hset en comptant avec du -b sol1.hs.
kdragon
@DragonGuy Je viens de faire la même chose et j'obtiens toujours 99. d' wcaccord, et j'ai vérifié les caractères non imprimables. Cette version de 84 octets fonctionne- t-elle? Si c'est le cas, je le prendrai :)
Kevin Reid
1

Haskell, 118

Ceci est ma première réponse de golf à code haskell et la voici:

f n=mapM_(putStrLn.s)[0..3*n]where;d x=(++)$take(3*n)$cycle x;s x|x`mod`3<1=d"+--""+"|x`mod`6<3=d"|  |##""|"|1<2=d"|##|  ""|"

Version plus lisible:

func num = do
    let -- Range
        rag = 3 * num
        -- `+--+`
        a = d "+--" "+"
        -- `|  |##`
        b = d "|  |##" "|"
        -- `|##|  `
        c = d "|##|  " "|"
        -- generate line
        d x y = take rag (cycle x) ++ y
        -- step
        step x
            | x `mod` 6 `elem` [1, 2] = b
            | x `mod` 3 == 0          = a
            | otherwise               = c

    mapM_ (putStrLn . step) [0..rag]

Sortie

*Main> :load test
[1 of 1] Compiling Main             ( test.hs, interpreted )
Ok, modules loaded: Main.
*Main> f 1
+
*Main> f 4
+--+--+--+--+
|  |##|  |##|
|  |##|  |##|
+--+--+--+--+
|##|  |##|  |
|##|  |##|  |
+--+--+--+--+
|  |##|  |##|
|  |##|  |##|
+--+--+--+--+
|##|  |##|  |
|##|  |##|  |
+--+--+--+--+
*Main> f 15
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
Afonso Matos
la source
f 1devrait produire 1 boîte vide, f 0produit juste le signe plus.
Kade
@ Vioz- Mon mauvais, donc cela rend le code encore plus court: P
Afonso Matos
1

C - 119 101

Utilise maintenant le calcul similaire à la réponse @ Sp3000. Associez également les optimisations.

i,j;f(n){for(i=j=0;j<=n*3;i++)putchar(i-n*3-1?" -|+#"[!(j%3)+2*!(i%3)?:(i/3+j/3)%2*4]:(j-=i=-1,10));}

Je pense que ?:c'est une extension GCC ...

Ancienne réponse:

f(n){int i,j;char p[]=" -|+";for(i=j=0;j<=n*3;*p=" #"[(i++/3+j/3)%2])putchar(i-n*3-1?p[!(j%3)+2*!(i%3)]:(j-=i=-1,10));}

Il maintient 2 coordonnées et calcule honnêtement quel caractère imprimer pour chaque paire. La liste des caractères à imprimer est stockée dans un tableau et cela seul imprime une grille "non colorée". Le premier élément du tableau est modifié pour dessiner des carrés noirs.

Je pourrais changer cela de sorte qu'au lieu de deux coordonnées indépendantes, il y ait une seule valeur comptant ou (peut-être même mieux) vers le bas, mais je ne peux pas envelopper ma tête autour de cela pour le moment.

Bonus - le remplacement de 3 par tout autre nombre entraîne un programme qui dessine un damier valide avec une taille de cellule différente.

aragaer
la source
1

awk - 91

{
    for(k=i=3*$0+1;i--;print"")
        for(j=k;j--;)printf i%3?j%3?234~(i+j)%6?FS:"#":j%3?"-":"|":"+"
}

C'était tout un combat pour le faire descendre en dessous de 100. Le comptage à rebours et l'utilisation de l'opérateur de match ont été les percées;) Le reste est à peu près logique.

Cabbie407
la source
0

Pyke, 47 octets, non concurrent

"+--"Q*\+j+i
QQ]Uas 2%" #"@2*)F\|JjR+"+
"+2*pi
<Newline needed>

Essayez-le ici!

Bleu
la source