Les boues sont des ennemis en forme de cube dans Minecraft qui se divisent en plusieurs versions plus petites d’eux-mêmes quand ils sont tués. Pour les besoins de ce défi, nous les représenterons comme une image 8 × 8 pixels avec 3 couleurs:

← Véritable version 8 × 8.

Les couleurs RVB précises sont:

• 0, 0, 0 pour les yeux et la bouche
• 110, 170, 90 pour le centre, vert plus foncé
• 116, 196, 96 pour l'extérieur, vert plus clair

Défi

Ecrivez un programme ou une fonction qui prend un entier positif N et génère une image de N tailles de slimes regroupées dans un rectangle. En allant de gauche à droite, l’image doit suivre le schéma suivant:

• Une pile de 2 ^(N-1) 8 × 8 boues.
• Une pile de 2 ^(N-2) 16 × 16 boues.
• Une pile de 2 ^(N-3) 32 × 32 boues.
• Et ainsi de suite jusqu'à ce que la pile ne contienne plus qu'un seul slime.

Les images visqueuses plus grandes que la version 8 × 8 ( ) sont générées par suréchantillonnage du voisin le plus proche (en doublant simplement tous les pixels). Notez que vous devez utiliser exactement le design et les couleurs de slime indiqués ici.

L'image finale contiendra 2 ^N -1 slimes et aura 2 ^{(N + 3)} -8 pixels de large et 2 ^{(N + 2)} pixels de haut.

L'image peut être sortie dans n'importe quel format de fichier d'image commun, enregistrée dans un fichier ou imprimée / renvoyée sous forme de flux de données brutes, ou directement affichée pendant l'exécution.

Le code le plus court en octets gagne.

Exemples

Votre programme devrait produire ces résultats exacts.

N = 1:

N = 2:

N = 3:

N = 4:

N = 5:

N = 6:

Un plus grand N devrait aussi bien fonctionner.

MATL , 77 76 74 octets

:"')^.,9&Xze`}+.E=p'F3ZaQ8e@qWt3$Y"G@-W1X"]&h[OOO;11 17E]5*29 7U24hhE&vEYG

Le code fonctionne dans ce commit , qui est antérieur au défi.

Vous pouvez l'essayer dans MATL en ligne . Cet interprète est encore expérimental. Si cela ne fonctionne pas, essayez d'actualiser la page et d'appuyer à nouveau sur "Exécuter".

Voici un exemple exécuté dans l'interpréteur hors ligne:

Explication

:                     % Input N implicitly. Generate range [1 2 ... N]
"                     % For each k in [1 2 ... N]
  ')^.,9&Xze`}+.E=p'  %   Compressed string
  F3Za                %   Decompress with target alphabet [0 1 2]
  Q                   %   Add 1
  8e                  %   Reshape into 8×8 array containing values 1, 2, 3
  @qW                 %   Push 2 raised to k-1
  t                   %   Duplicate
  3$Y"                %   Repelem: interpolate image by factor 2 raised to k-1
  G@-W                %   Push 2 raised to N-k
  1X"                 %   Repmat: repeat the array vertically. Gives a vertical strip
                      %   of repeated subimages
]                     % End for each
&h                    % Concatenate all vertical strips horizontally. This gives a big
                      % 2D array containing 1, 2, 3, which represent the three colors
[OOO;11 17E]5*        % Push array [0 0 0; 11 17 9] and multiply by 5
29 7U24hhE            % Push array [29 49 24] and multiply by 2
&vE                   % Concatenate the two arrays vertically and multiply by 2.
                      % This gives the colormap [0 0 0; 110 170 90; 116 196 96]
YG                    % Take the array and the colormap and display as an image

Dyalog APL, 118 113 octets

('P3',⌽∘⍴,255,∊)(3↑(116 196 96)(110 170 90))[⊃,/i{⊃⍪/⍵⍴⊂⍺⌿⍺/8 8⍴∊22923813097005 926134669613412⊤¨⍨⊂32⍴3}¨⌽i←2*⍳⎕]

en supposant ⎕IO=0

De droite à gauche:

i←2*⍳⎕ pouvoirs 1 2 4 ... 2 ^n-1

i{ }¨⌽iitérer sur les pouvoirs (avec ⍺) et les pouvoirs inversés ( ⍵)

⊤¨⍨⊂32⍴3 décoder chacun des nombres à gauche en 32 chiffres ternaires

8 8⍴∊ aplatir et remodeler à 8 × 8

⍺⌿⍺/reproduire chaque rangée et colonne ⍺fois

⍵⍴⊂prendre des ⍵copies

⊃⍪/ et les empiler verticalement

⊃,/ joindre tous les résultats horizontalement

3↑(116 196 96)(110 170 90)couleurs; 3↑les étend avec(0 0 0)

[ ]indexer les couleurs avec chaque élément de la matrice; le résultat est une matrice de RVB

('P3',⌽∘⍴,255,∊)est un "train" - une fonction qui retourne 'P3'suivie de la forme inversée de l'argument 255et de l'argument aplati.

JavaScript (ES7), 326 327 octets

n=>{x=(d=document).body.appendChild(c=d.createElement`canvas`).getContext`2d`;c.width=2*(c.height=4*(p=2**n)));for(i=0;i<n;i++){c=-1;for(j of[...'0001000001111110022112200221122011111110011121110111111000010000'])for(x.fillStyle=['#74c460','#6eaa5a','#000'][j],c++,k=0;k<p;)x.fillRect(c%8*(_=2**i)+_*8,~~(c/8)*_+_*8*k++,_,_)}}

Version ES6 Ungolfed

Essayez vous-même.

(n=>{
    x=(d=document).body.appendChild(c=d.createElement`canvas`).getContext`2d`;
    c.width=2*(c.height=4*(p=Math.pow(2,n)));
    for(i=0;i<n;i++){
        c=-1;
        for(j of[...'0001000001111110022112200221122011111110011121110111111000010000'])
            for(x.fillStyle=['#74c460','#6eaa5a','#000'][j],c++,k=0;k<p;)
                x.fillRect(c%8*(_=Math.pow(2,i))+_*8,~~(c/8)*_+_*8*k++,_,_)
    }
})(4);

La seule différence entre les versions ES7 et ES6 est d'utiliser **au lieu de Math.pow(). Vous pouvez également voir comment appeler la fonction - dans cet exemple avec n=4.

Résultat

Édite

• sauvé 1 octet - a trouvé un point-virgule final inutile;

^{Ceci est assez lent et peut prendre un certain temps pour des nombres supérieurs à 10.}

C, 220 octets

x,y,r;f(n){
printf("P3 %d %d 255 ",(8<<n)-8,4<<n);
for(y=0;y<4<<n;++y)for(r=0;r<n;++r)for(x=0;x<8<<r;++x)
puts("110 170 90\0 116 196 96\0 0 0 0"+12*
(117-"` t5L\rL\ru5tst5` "[x>>r+2|(y>>r)%8*2]>>(x>>r)%4*2&3));}

J'ai ajouté des nouvelles lignes inutiles pour la lisibilité, le score est sans ces nouvelles lignes.

Définit une fonction f(n)qui génère une image PPM simple sur stdout.

Mathematica, 267 255 254 225 212 octets

G=10{11,17,9};Image@Join[##,2]&@@Table[Join@@Table[ImageData@ImageResize[Image[{t={g=G+{6,26,6},g,g,G,g,g,g,g},f={g,a=##&[G,G,G],a,g},e={g,b=0g,b,G,G,b,b,g},e,{a,a,G,g},{g,a,b,a},f,t}/255],4*2^j],2^(#-j)],{j,#}]&

Sauvegardé 29 42 octets grâce à Martin Ender

Des suggestions de golf sont les bienvenues, en particulier pour la construction du tableau 8 x 8 (sur 3) s. Malheureusement, il n’existe pas d’ ArrayResizeanalogue pour ImageResize, le tableau doit donc être converti en image ( Image) avant de redimensionner, puis de nouveau en tableau ( ImageData) Join.

Ungolfed:

(* dark green, light green, black *)
G = 10 {11, 17, 9};
g = G + {6, 26, 6};
b = 0 g;

(* abbreviation for triple G sequence, top row, forehead, eye level *)
a = ##&[G, G, G];
t = {g, g, g, G, g, g, g, g};
f = {g, a, a, g};
e = {g, b, b, G, G, b, b, g};

(* slime *)
s =
  {
    t,
    f,
    e,
    e,
    {a, a, G, g},
    {g, a, b, a},
    f,
    t
  }/255;

(* jth column *)
c[n_, j_] := Join @@ Table[ImageData@ImageResize[Image[s], 4*2^j], 2^(n - j)]

(* final program *)
Image@Join[##, 2] & @@ Table[c[#, j], {j, #}] &

Python 2.7: 424 412 405 376 357 octets

Je suis un peu nouveau au golf .... on y va

from numpy import*
import PIL
def c(n,col):e=log2((col+8)/8)//1;r=2**e;t=2**(n-e-1);return tile(repeat(array([0x2df0777ca228b9c18447a6fb/3**i%3for i in range(64)],dtype=int8).reshape([8,8])[:,(col-(8*r-8))//r],r),t)
n=input();i=PIL.Image.fromarray(column_stack([c(n,col) for col in range(2**(n+3)-8)]),mode='P');i.putpalette('t\xc4`n\xaaZ'+' '*762);i.show()

ungolfed et longueur testé.

from numpy import*
import PIL

def c(n,col): #creates array for a given column
    s = array([0x2df0777ca228b9c18447a6fb/3**i%3for i in range(64)],dtype=int8).reshape([8,8]) #slime template (golfed inline)
    e=log2((col+8)/8)//1 #exponent for tiles and repititions
    r=2**e #number of repitions (scale factor)
    t=2**(n-e-1) #number of tiles (vertically)
    return tile(
            repeat(
             s[:,(col-(8*r-8))//r] #select appropriate column from template
              ,r) #repeat it r times
               ,t) #tile it t times

n = input()
arr = column_stack([c(n,col) for col in range(2**(n+3)-8)]) #create image array by stacking column function
i=PIL.Image.fromarray(arr,mode='P'); #colormap mode
i.putpalette('t\xc4`n\xaaZ'+' '*762); #set colormap
i.show()

s = r'''from numpy import*
import PIL
def c(n,col):e=log2((col+8)/8)//1;r=2**e;t=2**(n-e-1);return tile(repeat(array([0x2df0777ca228b9c18447a6fb/3**i%3for i in range(64)],dtype=int8).reshape([8,8])[:,(col-(8*r-8))//r],r),t)
n=input();i=PIL.Image.fromarray(column_stack([c(n,col) for col in range(2**(n+3)-8)]),mode='P');i.putpalette('t\xc4`n\xaaZ'+' '*762);i.show()'''

print len(s)

edit1: supprimé sys.argv[1]en faveur de l' raw_input()enregistrement d'une déclaration d'importation supplémentaire

edit2: importation abrégée de PIL: supprimé from ImageajoutéPIL.

edit3: Merci @ Sherlock9 pour le code hexadécimal du modèle slime

edit4: n'a pas besoin de la fonction def et utilisé à la input()place deraw_input()

R, 378 356 346 334 octets

f=function(n){r=rep;k=r(0,4);m=r(1,6);L=c();for(i in 1:n)L=cbind(L,r(max(L,0)+2^(n-i):1,e=2^(i-1)));png(w=sum(w<-4*2^(1:n)),h=sum(h<-r(8,2^(n-1))));layout(L,w,h);for(i in 1:max(L)){par(mar=k);image(matrix(c(0,0,0,1,k,0,m,0,0,1,1,1,2,r(1,10),0,0,r(r(c(2,1,2,0),e=2),2),m,k,1,k),nr=8),col=c("#74C460","#6EAA5A",1),ax=F,an=F)};dev.off()}

Enregistre en tant que fichier png. En retrait, avec sauts de ligne:

f=function(n){
    r=rep
    k=r(0,4)
    m=r(1,6)
    L=c()
    for(i in 1:n)L=cbind(L,r(max(L,0)+2^(n-i):1,e=2^(i-1)))
    png(w=sum(w<-4*2^(1:n)),h=sum(h<-r(8,2^(n-1))))
    layout(L,w,h)
    for(i in 1:max(L)){
        par(mar=k)
        image(matrix(c(0,0,0,1,k,0,m,0,
                       0,1,1,1,2,r(1,10),0,
                       0,r(r(c(2,1,2,0),e=2),2),
                       m,k,1,k),
                     nr=8),
              col=c("#74C460","#6EAA5A",1),ax=F,an=F)
    }
    dev.off()
}

N = 2: N = 3: N = 4:

Quelques explications:

Voici la matrice en cours de tracé (0 représente le vert clair, 1 le vert foncé et 2 le noir; la matrice est inclinée car les colonnes sont l'axe des y et les lignes l'axe des x):

     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8]
[1,]    0    0    0    1    0    0    0    0
[2,]    0    1    1    1    2    2    1    0
[3,]    0    1    1    1    2    2    1    0
[4,]    1    1    1    1    1    1    1    1
[5,]    0    1    2    1    1    1    1    0
[6,]    0    1    1    1    2    2    1    0
[7,]    0    1    1    1    2    2    1    0
[8,]    0    0    1    0    0    0    0    0

Chaque appel à imagetracer cette matrice (chaque entier correspondant à une couleur). Pour N = 4, voici L (la matrice de présentation, chaque numéro unique représente un seul tracé), w (les largeurs des colonnes de la matrice) et h (les hauteurs des lignes de la matrice):

> L
     [,1] [,2] [,3] [,4]
[1,]    8   12   14   15
[2,]    7   12   14   15
[3,]    6   11   14   15
[4,]    5   11   14   15
[5,]    4   10   13   15
[6,]    3   10   13   15
[7,]    2    9   13   15
[8,]    1    9   13   15
> w
[1]  8 16 32 64
> h
[1] 8 8 8 8 8 8 8 8