मारेक Minecraft में घन के आकार के दुश्मन हैं जो मारे जाने पर खुद के कई छोटे संस्करणों में टूट जाते हैं। इस चुनौती के प्रयोजनों के लिए हम उन्हें 3 रंगों के साथ 8 × 8 पिक्सेल छवि के रूप में चित्रित करेंगे:

8 सच 8 × 8 संस्करण।

सटीक आरजीबी रंग हैं:

0, 0, 0 आंखों और मुंह के लिए
110, 170, 90 केंद्रीय के लिए, गहरा हरा
116, 196, 96 बाहरी के लिए, हल्का हरा

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो एक सकारात्मक पूर्णांक एन में लेता है और एक आयत में पैक एन के आकार की एक छवि को आउटपुट करता है। बाईं से दाईं ओर जा रहे हैं, छवि को होने के पैटर्न का पालन करना चाहिए:

2 ^(N-1) 8 × 8 स्लाइस का ढेर ।
2 ^(N-2) 16 × 16 स्लाइस का ढेर ।
2 ^(N-3) का एक ढेर 32 × 32 का टुकड़ा।
और इसलिए जब तक स्टैक में केवल एक कीचड़ होता है।

8 × 8 संस्करण ( ) से बड़ी कीचड़ वाली छवियां निकटतम-पड़ोसी अपसम्पलिंग (यानी सिर्फ सभी पिक्सेल को दोगुना करके) द्वारा उत्पन्न की जाती हैं । ध्यान दें कि आपको यहां दिए गए सटीक कीचड़ डिजाइन और रंगों का उपयोग करना चाहिए।

अंतिम छवि में 2 ^N -1 स्लिम्स होंगे और 2 ^{(N + 3)} -8 पिक्सेल चौड़े और 2 ^{(N + 2)} पिक्सेल लम्बे होंगे।

छवि किसी भी सामान्य छवि फ़ाइल प्रारूप में आउटपुट हो सकती है, एक फ़ाइल में सहेजी जा सकती है या एक कच्चे डेटा स्ट्रीम के रूप में मुद्रित / वापस हो सकती है, या सीधे रनटाइम के दौरान प्रदर्शित की जा सकती है।

बाइट्स में सबसे छोटा कोड जीतता है।

उदाहरण

आपके कार्यक्रम को इन सटीक परिणामों का उत्पादन करना चाहिए।

एन = 1:

एन = 2:

एन = 3:

एन = 4:

एन = 5:

एन = 6:

बड़ा एन भी काम करना चाहिए।

— केल्विन के शौक
स्रोत

30

मैं उत्थान करूंगा लेकिन मेरे पास कोई वोट नहीं बचा है। मैं इस टिप्पणी को छोड़ रहा हूँ ताकि मैं कल को याद करूँ।

— NoOneIsHere

23

मैं आपकी टिप्पणी को बढ़ा-चढ़ाकर बता रहा हूं क्योंकि मैं भी अपवित्र हो चुका हूं।

— ट्राइकोप्लाक्स

4

"8 × 8 संस्करण (are) से बड़ी कीचड़ वाली छवियां निकटतम-पड़ोसी अपसम्पलिंग (यानी सिर्फ सभी पिक्सेल को दोगुना करके) द्वारा उत्पन्न की जाती हैं।" क्या आप सभी पिक्सेल को चौगुनी करते हैं, प्रत्येक पिक्सेल को 2x2 वर्ग में बनाते हैं?

— कारिडोरक

1

@Caridorc प्रत्येक दिशा में दोहरीकरण?

— 14 अक्टूबर को wizzwizz4

@ wizzwizz4 हाँ, प्रत्येक पिक्सेल 4 सही हो जाता है?

— कारिडोरक

21

MATL , 77 76 74 बाइट्स

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

इस प्रतिबद्ध में कोड काम करता है , जो चुनौती से पहले है।

आप इसे ऑनलाइन MATL में आज़मा सकते हैं । यह दुभाषिया अभी भी प्रायोगिक है। यदि यह काम नहीं करता है, तो पृष्ठ को फिर से ताज़ा करने और "रन" को फिर से दबाने का प्रयास करें।

यहाँ एक उदाहरण ऑफ़लाइन दुभाषिया में चलाया गया है:

व्याख्या

:                     % 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

— लुइस मेंडो
स्रोत

"लार्ज एन को बस काम करना चाहिए।", लेकिन आपका आउट ऑफ मेमोरी / इंडेक्स एरर पहले से ही n = 9. पर देना प्रतीत होता है। क्या यह केवल ऑनलाइन इंटरप्रेटर है या ऑफलाइन वर्जन में भी ऐसा होता है?

— डेविड मुल्डर

1

@DavidMulder मैंने ऑफ़लाइन परीक्षण किया है (मैटलैब R2015 बी, विंडोज 7 64 बिट्स, 4 जीबी रैम पर चलने वाला कंपाइलर) इनपुट के लिए परीक्षण किया है 11और यह काम करता है। के लिए 11परिणाम एक 8192 × 16,376 छवि है। इसके लिए 1216384 × 32760 (536 मेगापिक्सल) की आवश्यकता होगी, इसके लिए 4 जीबी से अधिक रैम की आवश्यकता होती है, जो कि मेरे लैपटॉप की तुलना में अधिक है।

— लुइस मेंडो

2

मुझे पसंद है कि कैसे कोड एक स्माइली के साथ शुरू होता है जो तीव्र भावनाओं के कारण अपने आँसू वापस खींच रहा है यह कोड उसे महसूस करता है: "')

— टॉम डूडलर

14

डायलाग एपीएल, 118 113 बाइट्स

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

यह सोचते हैं ⎕IO=0

दांये से बांये तक:

i←2*⍳⎕ शक्तियाँ 1 2 4 ... 2 ^n-1

i{ }¨⌽iशक्तियों के साथ पुनरावृत्ति ( ⍺) और उलट शक्तियां ( ⍵)

⊤¨⍨⊂32⍴3 बाईं ओर की प्रत्येक संख्या को 32 तिरछे अंकों के रूप में डिकोड करें

8 8⍴∊ चपटा और 8 × 8 के जैसा दिखता है

⍺⌿⍺/प्रत्येक पंक्ति और कॉलम ⍺बार दोहराएं

⍵⍴⊂⍵प्रतियां ले लो

⊃⍪/ और उन्हें लंबवत रूप से स्टैक करें

⊃,/ क्षैतिज रूप से सभी परिणामों में शामिल हों

3↑(116 196 96)(110 170 90)रंग की; 3↑के साथ उन्हें बढ़ाता है(0 0 0)

[ ]मैट्रिक्स के प्रत्येक तत्व के साथ रंगों को अनुक्रमित करें; परिणाम RGBs का एक मैट्रिक्स है

('P3',⌽∘⍴,255,∊)एक "ट्रेन" है - एक फ़ंक्शन जो 'P3'तर्क के उलट आकार के बाद लौटता है 255, और तर्क चपटा हुआ है।

— NGN
स्रोत

मुझे लगता है कि आप अपने कार्यक्रम को लिख सकते हैं ⎕IO←0और इसे एक शर्त के रूप में बता सकते हैं, बाइट काउंट के बाहर। कई एपीएल सिस्टम एक डिफ़ॉल्ट के रूप में उपयोग करते हैं। (आपका एलओएल सहित)

— तोबिया

11

जावास्क्रिप्ट (ईएस 7), 326 327 बाइट्स

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++,_,_)}}

Ungolfed ES6 संस्करण

इसे स्वयं आज़माएं।

(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);

ईएस 7 और ईएस 6 संस्करण के बीच एकमात्र अंतर **इसके बजाय उपयोग कर रहा है Math.pow()। आप यह भी देख सकते हैं, कि आप किस तरह से फंक्शन को शुरू कर सकते हैं - इस उदाहरण में n=4।

नतीजा

संपादित करता

1 बाइट बचाया - एक अनावश्यक अनुगामी अर्धविराम मिला;

^{यह बहुत धीमा है और संख्या 10 से अधिक होने में कुछ समय लग सकता है।}

— insertusernamehere
स्रोत

2

यहाँ छवि में रंग थोड़े बंद लग रहे हैं। क्या आपने शायद f.lux पर स्क्रीनशॉट लिया है?

— जेजामोन

@Jezzamon इसे इंगित करने के लिए धन्यवाद - मैंने यह भी नोटिस किया था। वहाँ एक है मामूली संभावना है कि मैं हो सकता है "को चुना है काम की जगह के लिए दस्तावेज़ के रंग कन्वर्ट " जबकि में फ़ोटोशॉप स्क्रीनशॉट का आयात। अब छवि ठीक हो गई है।

— आवेषण

@ गिल्स - आपकी टिप्पणी की सराहना करते हैं, और एसओ में, यह पूरी तरह से उचित होगा, लेकिन यहां, हम दूसरों के कार्यक्रमों को नहीं बदलते हैं - हम उन्हें टिप्पणियों में बताते हैं।

— नहीं कि चार्ल्स

7

सी, 220 बाइट्स

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));}

मैंने पठनीयता के लिए बेकार की नई कहानियों को जोड़ा, स्कोर इन नई कहानियों के बिना है।

एक फ़ंक्शन को परिभाषित करता है f(n)जो stdout पर एक सादे PPM छवि को आउटपुट करता है ।

— orlp
स्रोत

1

किसी कारण के लिए सी जवाब मेरे दिमाग में बहुत सुंदर हैं।

— downrep_nation

7

गणितज्ञ, 267 255 254 225 212 बाइट्स

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,#}]&

सहेजे गए 29 मार्टिन Ender 42 बाइट्स धन्यवाद

गोल्फ सुझाव का स्वागत करते हैं, विशेष रूप से 8 बाय 8 (3) सरणी के निर्माण के लिए s। दुर्भाग्य से, इसके लिए कोई ArrayResizeअनुरूपण नहीं है ImageResize, इसलिए सरणी को Imageआकार बदलने से पहले एक छवि ( ) में परिवर्तित किया जाना चाहिए , और फिर एक सरणी ( 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, #}] &

— अखिरी सहारा
स्रोत

1

b=0g। इसे बनाने के sलिए आधार -3 नंबर के रूप में पिक्सेल मानों को एनकोड करना कम हो सकता है, लेकिन मुझे यकीन है कि कोशिश करनी होगी। इस दौरान, आप बाइट्स को परिभाषित नहीं द्वारा बचा सकता है b, g, f, e, tजब तक आप उन्हें जरूरत है, और sसभी में एक नाम की जरूरत नहीं है और न ही करता है c। 2^(j-1)8आप के लिए उपयोग कर सकते हैं 4*2^j। उन सभी को लागू करते हुए, मैं 225 बाइट्स पर समाप्त होता हूं: pastebin.com/YnkUwvwV

— मार्टिन एंडर

@MartinEnder बहुत आभार, ये सभी बहुत अच्छे सुझाव हैं! : (बातें यदि संभव हो तो नामकरण से बचने, अन्यथा पर (बल्कि पहले की तुलना में काम करते हैं) पहली घटना स्वयं के लिए नोट।)

— lastresort

मैं पूरी तरह से इसे अभी यह पता लगाने की समय नहीं है, लेकिन यहाँ एक विचार से बचने के लिए है Image, ImageResize, ImageDataसामान। यह बिट 2 के एक कारक द्वारा एक सरणी को उड़ा देता है: #&@@{##&@@{#,#}&//@x}जहां xसरणी है। इसलिए यदि आप एक चर में शुरुआती 8x8 ग्रिड को स्टोर करते हैं x, और फिर x=#&@@{##&@@{#,#}&//@x}प्रत्येक उपयोग के बाद करते हैं, तो आप क्रमिक टाइल्स को काफी आसानी से उत्पन्न कर सकते हैं।

— मार्टिन एंडर

वूप्स, यह 4 बाइट्स की तुलना में अधिक समय तक होना चाहिए:#&[##&[#,#]&//@x]

— मार्टिन एंडर

हम्म, मैं यह अभी तक काम करने के लिए नहीं मिल रहा है, लेकिन आप एक से कुछ अधिक बचा सकता है) का उपयोग कर ##~Join~2और ख) f={g,a=##&[G,G,G],a,g}और उसके बाद के हर आगे घटना की जगह G,G,Gके साथ aके रूप में अच्छी तरह से।

— मार्टिन एंडर

4

पायथन 2.7: 424 412 405 376 357 बाइट्स

मैं थोड़ा नया हूँ गोल्फ के लिए .... यहाँ हम चलते हैं

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()

अपुष्ट और लंबाई परीक्षण किया ..

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: अतिरिक्त आयात विवरण को बचाने के sys.argv[1]पक्ष में हटा दिया गयाraw_input()

edit2: छोटा PIL आयात: हटा दिया from ImageगयाPIL.

edit3: धन्यवाद @ शर्लक 9 के लिए हेम सांकेतिक शब्दों में बदलना टेम्पलेट

edit4: के input()बजाय फ़ंक्शन डीईएफ़ और उपयोग की आवश्यकता नहीं थीraw_input()

— हारून
स्रोत

किसी भी सुझाव का स्वागत से अधिक है :) खासतौर पर टेम्प्लेट ऐरे को सिकोड़ने के लिए

— हारून

उपयोग करने जैसा कुछ '0000100001111110111211100111111102211220022112200111111000001000'(आपकी सरणी पीछे की ओर) बेस 3 से बेस 16 में परिवर्तित हो गया 0x2df0777ca228b9c18447a6fb। उस संख्या के साथ, [0x2df0777ca228b9c18447a6fb//3**i%3 for i in range(64)]अपने पूर्णांक को सही क्रम में लाने के लिए इस तरह कोड का उपयोग करें ।

— शर्लक 9

आह, पायथन 2 में, [0x2df0777ca228b9c18447a6fb/3**i%3for i in range(64)]बेहतर हो सकता है।

— शर्लक 9

धन्यवाद @ शर्लक 9 गोल्फिंग में नए हैं, क्या आप बता सकते हैं कि यह (मुझे लगता है) आधार कोड कार्यों में बदलाव कैसे हुआ?

— हारून

1

दूसरा भाग उस नंबर से आपके एरे को वापस प्राप्त करना है 0x2df0777ca228b9c18447a6fb। यह सरल है। एक सरल उदाहरण के लिए, से 0वें अंक प्राप्त करने के लिए 01221100, बस 3 0बार विभाजित करें , और फिर प्राप्त करने के लिए अंतिम अंक (मॉड 3 का उपयोग करके) लें 0। 2 अंक लेने के लिए, 3 2गुना से विभाजित करें , फिर प्राप्त करने के लिए 3 मोड 1। सूची बोध 64आपके पूर्ण सरणी को वापस पाने के लिए सिर्फ 3 बार विभाजित करता है । यदि आपके कोई और प्रश्न हैं, तो हम पीपीसीजी चैट में उनकी चर्चा कर सकते हैं ।

— शर्लक 9

1

आर, 378 356 346 334 बाइट्स

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()}

एक png फ़ाइल के रूप में सहेजता है। पंक्तिबद्ध फ़ीड के साथ

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()
}

एन = २: एन = ३: एन = ४:

कुछ स्पष्टीकरण:

यहां वह मैट्रिक्स है जो प्लॉट किया जा रहा है (0 लाइटग्रीन, 1 डार्कग्रीन और 2 ब्लैक का प्रतिनिधित्व करता है; मैट्रिक्स झुका हुआ है क्योंकि कॉलम y- एक्सिस हैं और एक्स-एक्सिस पंक्तियाँ हैं):

     [,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

प्रत्येक कॉल imageउस मैट्रिक्स को प्लॉट करने के लिए (रंग के अनुरूप प्रत्येक पूर्णांक के साथ)। N = 4 के लिए, यहाँ L (लेआउट मैट्रिक्स, प्रत्येक अद्वितीय संख्या एक एकल भूखंड का प्रतिनिधित्व करती है), w (मैट्रिक्स कॉलम की चौड़ाई) और h (मैट्रिक्स पंक्तियों की ऊँचाई):

> 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

— plannapus
स्रोत

घातीय स्लीमी प्रोग्रामिंग: स्टैकिंग माइनक्राफ्ट स्लीम्स

चुनौती

उदाहरण

MATL , 77 76 74 बाइट्स

व्याख्या

डायलाग एपीएल, 118 113 बाइट्स

जावास्क्रिप्ट (ईएस 7), 326 327 बाइट्स

सी, 220 बाइट्स

गणितज्ञ, 267 255 254 225 212 बाइट्स

पायथन 2.7: 424 412 405 376 357 बाइट्स

आर, 378 356 346 334 बाइट्स