इस संशोधित सर्कल के साथ विमान को टाइल करें

Question

मूल पर केंद्रित एक इकाई चक्र लें। किसी भी दो पड़ोसी क्वाड्रंट्स में , सर्कल के एक्स और वाई इंटरसेप्ट को जोड़ने वाली लाइनों के पार सर्कल के वक्र को मिरर करें।

परिणामस्वरूप आकार के साथ, आप विमान को टाइल कर सकते हैं:

^{मैंने इस छवि को भयानक 2D भौतिकी सैंडबॉक्स अल्गोडू के साथ बनाया है !}

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

नियम:

• पूरे खड़ी ओर इशारा करते हुए टाइल्स, क्षैतिज ओर इशारा करते हुए टाइल्स लिए एक-एक: छवि किसी भी दो चाक्षुष रूप से भिन्न आरजीबी रंग का उपयोग कर संशोधित सर्कल टाइल के साथ tessellated किया जाना चाहिए।

• सर्कल टाइल्स की त्रिज्या कम से कम 32 पिक्सेल होनी चाहिए। (ऊपर की छवि में त्रिज्या लगभग 110 पिक्सेल है।)

• छवि कम से कम 4 टाइलें चौड़ी और 4 टाइलें ऊंची होनी चाहिए। यह, ऊपर के नियम के साथ संयुक्त, इसका मतलब है कि छवियों का न्यूनतम आकार 256 × 256 पिक्सेल हो सकता है। (ऊपर की छवि 4 टाइलों द्वारा 4 टाइलों की है।)

• किसी भी राशि से टेसूलेशन का अनुवाद किया जा सकता है। उदाहरण के लिए, छवि के ऊपरी बाएं कोने को शीर्ष पर स्थित होने की आवश्यकता नहीं है जहां टाइल मिलते हैं। (हालांकि, तहखाने को घुमाया नहीं जाना चाहिए।)

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

• घटता वास्तव में लगभग हलकों चाहिए, जैसा कि midpoint सर्कल एल्गोरिथ्म के साथ किया जा सकता है , जो कि अधिकांश ग्राफिक्स लाइब्रेरी आपके लिए करेंगे।

• टाइल्स के किनारों के आसपास एंटी-अलियासिंग की अनुमति है लेकिन आवश्यक नहीं है।

बाइट्स में सबसे कम सबमिशन जीतता है।

Answer 1

gs2, 49 बाइट्स

50 31 05 0d 1f 2a 48 0a 1e 2e 40 83 2c e8 64 2d
1e 73 ed 1e 33 40 20 30 9a a2 22 e8 e9 40 20 30
9a 30 40 20 30 ee 40 20 30 12 32 e9 12 32 55 e8
2b

एक पीबीएम छवि बनाता है:

स्मृति सहायकों:

# Print header
"P1" space 256 double
2dup new-line

# Make 1/4 circle
64 range dup cartesian-product
square m1 sum sqrt 64 >= m6
64 /

# Make tile
dup reverse + transpose
@2 not m1 m2
dup reverse + transpose
+

# Make quarter of image
dup reverse + z1
dup reverse +

# Loop
2 * m2
2 *

# Format
show-words m1
unlines

Answer 2

पीओवी-रे, 199 163

Old version
camera{location -9*z}light_source{-9*z}#declare L=union{#for(X,-9,9,2)#for(Y,-9,9,2)cylinder{X*x+x+Y*y,<.001*pow(-1,(X+Y)/2),0,.1>+X*x+x+Y*y,1}#end#end}object{L pigment{color x}}object{L rotate z*90}

Same output, but golfed down further by using default light/camera, so I dont even need to specify them
#declare L=union{#for(X,-9,9,2)#for(Y,-9,9,2)cylinder{<X+1,Y,9>,<.001*pow(-1,(X+Y)/2),0,.1>+<X+1,Y,9>,1}#end#end}object{L pigment{color rgb x}rotate z*90}object{L}

मैं कैमरे और लाइटसोर्स के लिए कई डिफ़ॉल्ट मापदंडों का उपयोग कर रहा हूं, यही कारण है कि यह थोड़ा अंधेरा है। पहले इसे अनफॉल्‍ट करें

camera{location 9*z look_at 0}
light_source{9*z color 1} 
#declare L=union{
    #for(X,-9,9,2)
        #for(Y,-9,9,2)
            cylinder{<1+X,Y,0>,                                 //central axis, start
                     <1+X,Y,0> + <.001*pow(-1,(X+Y)/2), 0, .1>, //central axis, end
                      1}                                        //radius
        #end         
    #end
}                         
object{L pigment{color x}} // x is the <1,0,0> vector, here interpreted as RGB
object{L rotate<0,0,90>}

यह स्पष्ट है कि क्या हो रहा है एक बार जब हम सिलेंडर अक्ष के ऑफसेट को बढ़ाते हैं और परिप्रेक्ष्य बदलते हैं

Comments

3 डी परिप्रेक्ष्य के लिए किनारों को थोड़ा विकृत नहीं किया जाएगा?

— orlp

की ऊँचाई के साथ 0.1और 0.001डिस्क की एक ऑफसेट $ \ phi = \ arctan (0.01) = 0.57 ° $ से झुकी हुई है, ऊपर से देखने पर डिस्क $ $ cos (\ phi) के एक कारक द्वारा निचोड़ा हुआ दिखाई देती है - 0.99995 $, एक पिक्सेल की तुलना में बहुत कम है।

— डेनडेनडो

@DenDenDo क्या अनंत काल में कैमरा लगाने में सक्षम नहीं है?

— रैंडम 832

@ Random832 इसके साथ, कर सकते हैं camera{orthographic location -9z}। लेकिन चूंकि दृश्य मूल रूप से 2 डी है, इससे कोई फर्क नहीं पड़ता है, आप angle 170परिणाम में किसी भी फिशये विरूपण के बिना इसे देखने के साथ भी प्रस्तुत कर सकते हैं ।

— डेनडेनडो

Answer 3

ग्नूप्लोट, 182

मैंने देखा कि कोशिकाओं के बीच की सीमाएं बहुत अधिक साइनसोइडल दिखती हैं, इसलिए मैं एक विश्लेषणात्मक समाधान के लिए बहुत सरल कोर समीकरण के साथ गया

set view map
set isosamples 900
f(x,y)=.3*sin(x*3.14)+y
splot(ceil(f(x,y))+ceil(f(y,x)))%2?1:NaN   #can only modulo integers

जबकि यह समान दिखता है, वैसे ही सर्कल भी चौकोर हैं। इसी विचार के साथ, मैं की जगह sinconcatenated quartercircle-आर्क्स से बनाया गया एक वक्र द्वारा और यह 45 बारी बारी से ° प्रतिस्थापित करके xऔर yसाथ x+yऔरx-y

set view map
set samples 800
set isosamples 800
d=.5**.5
c(x,k)=(-1)**k*sqrt(1-(x-d*(1+2*k))**2)-(-1)**k*d  # k-th circle arc
# s(x)=c(x,floor(x/d/2))                           # circlified sinus
# f(x,y)=d*s(x/d)+y
f(x,y)=d*c(x/d,floor(x))+y                         # combined commented functions
splot(ceil(f(x+y,x-y))+ceil(f(x-y,x+y)))%2?1:NaN

Answer 4

संदर्भ नि: शुल्क, 99 बाइट्स

startshape d CF::Tile=[s 4]CF::Symmetry=CF::pmg,0,1,0path d{ARCTO(-1,1,1)ARCTO(1,1,-1)ARCTO(0,0,1)}

आप परिणाम को नि: शुल्क गैलरी में देख सकते हैं ।

Comments

एक अच्छा, यह प्रसंग मुक्त का एक अद्भुत उपयोग है। :)

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

Answer 5

HTML + जावास्क्रिप्ट, 277

<canvas id=C></canvas><script>r=50,C.width=C.height=9*r,T=C.getContext('2d');
for(f=1,P=Math.PI,i=0;i<45;f=-f,i+=i&7?1:2)x=2*r*(i%8-2),y=2*r*(i>>3),T.moveTo(x,y+f*r),
T.arc(x+r,y+f*r,r,P,-f*P/2,f<0),T.arc(x,y,r,0,P,f>0),T.arc(x-r,y+f*r,r,-f*P/2,0,f<0);
T.fill()</script>

परीक्षण करने के लिए, html फ़ाइल के रूप में सहेजें और ब्राउज़र के साथ खोलें। या फिर, स्निपेट चलाएं

r=50,C.width=C.height=9*r,T=C.getContext('2d')
for(f=1,P=Math.PI,i=0;i<45;f=-f,i+=i&7?1:2)
  x=2*r*(i%8-2),y=2*r*(i>>3),
  T.moveTo(x,y+f*r),
  T.arc(x+r,y+f*r,r,P,-f*P/2,f<0),
  T.arc(x,y,r,0,P,f>0),
  T.arc(x-r,y+f*r,r,-f*P/2,0,f<0)
T.fill()

<canvas id=C></canvas>

लोकप्रिय मांग के कारण, यहां आउटपुट छवि है। इतना रोमांचक नहीं आखिर ...

Comments

आप एक छवि पोस्ट करना चाहते हैं ताकि कोड को हर बार किसी को आउटपुट देखने के लिए नहीं चलाना पड़े।

— केल्विन के शौक

@ केल्विन के शौकीन ओह, यह काफी तेज है और हर आधुनिक ब्राउज़र में चलता है। मैं इसके बजाय छवि को बड़ा करूँगा

— edc65

यह सच है। मुझे लगा कि यह =>आपके बहुत सारे पोस्ट की तरह इस्तेमाल होता है और यह केवल फ़ायरफ़ॉक्स में काम करेगा। लेकिन कोई चिंता नहीं।

— केल्विन के शौक

छवि पोस्ट करने का बेहतर कारण: ये स्निपेट्स मोबाइल पर बहुत अच्छी तरह से काम नहीं करते हैं :(

— Sp3000

Answer 6

आईडीएल 8.3, 201 193 183 बाइट्स

छवि एक IDL ग्राफिक्स विंडो में आउटपुट है; मैंने नीचे स्क्रीनशॉट लिया।

संपादित करें: @AlexA के लिए धन्यवाद। और @ मुझे कुछ बाइट शेव करने में मदद करने के लिए Sp3000

p=!pi/99*[0:99]
q=p[49:0:-1]
o=p[99:50:-1]
window,xs=(ys=400)
for i=0,24 do cgpolygon,i mod 5*100+50*[cos(p),cos(q)-1,cos(o)+1],i/5*100+(-1)^i*50*[sin(p),sin(q)-1,sin(o)-1],/d,/fi
end

Answer 7

गणित: 86 बाइट्स (या 82 बाइट्स)

एक चतुर सरणी-आधारित पद्धति के लिए अनंत @alephalpha के लिए धन्यवाद :

Image@ArrayFlatten@Array[DiskMatrix@32~RotateLeft~32/.a_/;OddQ@+##:>1-Thread@a&,{5,5}]

सरणी के अंदर एक अनाम फ़ंक्शन है, जो अपने तर्कों को जोड़ने के लिए एक चतुर चाल का उपयोग करता है ( +##) और निर्धारित करता है कि योग विषम है। उस बूलियन को एक पैटर्न के सशर्त के रूप में प्रयोग किया जाता है जो पूरे 'सफेद' टाइल को बदलकर, 'ब्लैक' टाइल के साथ बदल देता है। वहां से, ArrayFlattenटाइलों को एक साथ जोड़ते हैं और Imageउन्हें प्रदर्शित करते हैं।

नोट Threadबदलने के लिए छोटे के उपयोग पर ध्यान दें Transpose। हम अभी भी ट्रांसपोज़ सिंबल का उपयोग करके 4 बाइट्स बचा सकते हैं।

पिछला: 97 बाइट्स (या 90 बाइट्स)

Image@ArrayFlatten@Partition[
 Join@@Table[{#,1-Transpose@#}&@RotateLeft[DiskMatrix@32,32],{13}],5]

आप Transpose@#सुपरस्क्रिप्ट-टी सिंबल (कोडपॉइंट U + F3C7, शॉर्टकट ESCtrESC) से बदलकर बाइट्स की संख्या कम कर सकते हैं । UTF-8 में जो 88 वर्णों में कुल 90 बाइट्स लाता है ।

हम शुरू करते हैं DiskMatrix, जो एक बाइनरी मैट्रिक्स उत्पन्न करता है:

DiskMatrix@32 // Image

हम तब मैट्रिक्स की पंक्तियों को परिपत्र-शिफ्ट करते हैं ताकि टाइलिंग के लिए यूनिट सेल का उत्पादन किया जा सके:

RotateLeft[DiskMatrix@32, 32] // Image

यदि विमान एक शतरंज की बिसात है, तो ये 'सफेद' वर्ग हैं। 'ब्लैक' वर्गों के लिए, हमें रंगों को उल्टा करने और 90 डिग्री तक घुमाने की आवश्यकता है। हम 1 ( 1 - 1 -> 0और 1 - 0 -> 1) से घटाकर उल्टा कर सकते हैं , और पारगमन लेकर घूम सकते हैं:

Image /@ {#, 1 - Transpose@#} &@RotateLeft[DiskMatrix@32, 32]

यदि छवि के आयाम समान हैं (न्यूनतम आकार की तरह, 4), तो दाहिने किनारे पर एक टाइल बाएं किनारे पर अगले एक के समान होगी। हालाँकि, विषम आकार (5) प्राप्त करने के लिए एक टाइल जोड़ने पर पंक्तियों को समतल करने से एक नियमित रूप से वैकल्पिक पैटर्न का निर्माण होता है।

यह बताता है कि हम वैकल्पिक टाइलों की एक पंक्ति को लपेटकर पूरी छवि प्राप्त कर सकते हैं Partition। हम काले / सफेद टाइल जोड़े Tableकी एक सूची बनाने के लिए 13, और Join26 टाइल्स की सूची में जोड़े की सूची को समतल करने के लिए उपयोग करते हैं। फिर हम टाइल्स के मैट्रिक्स द्वारा Partitionसूची ( अनुगामी 26 ^वें टाइल को छोड़ते हैं):55Partition

Map[Image] /@ 
  Partition[
   Join @@ Table[{#, 1 - #\[Transpose]} &@
      RotateLeft[DiskMatrix@32, 32], {13}], 5] // MatrixForm

अंत ArrayFlattenमें टाइल मैट्रिक्स के मैट्रिक्स को एक फ्लैट मैट्रिक्स में बदल देता है, और Imageपरिणाम प्रदर्शित करता है।

पिछला: 111 बाइट्स

Image[ArrayFlatten[{{#, #}, {#, #}}] &[
  Join[#, Reverse@#, 2] &[
   Join[1 - Transpose@#, #] &@RotateLeft[DiskMatrix[32], 32]]]]

Comments

Image@ArrayFlatten@Array[RotateLeft[DiskMatrix@32,32]/.a_/;OddQ[+##]:>1-Thread@a&,{5,5}]

— एलेफाल्फा

Answer 8

जावा, 550 540 508 504 बाइट्स

यह एक जावा एप्लेट है।

import java.awt.*;public class T extends java.applet.Applet{int a=98,b=49,x,y;public void paint(Graphics g){for(x=0;x<5;x++)for(y=0;y<5;y++)a(g.create(x*a,y*a,a,a),x%2^y%2);}void a(Graphics g,int c){if(c>0){g.translate(a,0);((Graphics2D)g).scale(-1,1);}g.setColor(Color.red);g.fillRect(0,0,b,b);g.fillRect(b,b,b,b);g.setColor(Color.blue);g.fillRect(b,0,b,b);g.fillRect(0,b,b,b);g.fillArc(0,-b,a,a,180,90);g.fillArc(0,b,a,a,0,90);g.setColor(Color.red);g.fillArc(-b,0,a,a,0,-90);g.fillArc(b,0,a,a,90,90);}}

बॉयलरप्लेट के साथ विस्तारित:

import java.awt.*;
public class T extends java.applet.Applet{
    int a = 98, b = 49, x, y; //Make these larger for better quality pictures. a = b * 2
    public void paint(Graphics g) {
        for (x=0; x < 5; x++)      //Make these larger for more tiles.
            for (y=0; y < 5; y++)  //
                a(g.create(x * a, y * a, a, a), x % 2 ^ y % 2);
    }

    void a(Graphics g, int c) {
        if (c > 0) {
            g.translate(a, 0);
            ((Graphics2D) g).scale(-1, 1);
        }
        g.setColor(Color.red);            //Change colors for nicer looking colors.
        g.fillRect(0, 0, b, b);
        g.fillRect(b, b, b, b);
        g.setColor(Color.blue);
        g.fillRect(b, 0, b, b);
        g.fillRect(0, b, b, b);
        g.fillArc(0, -b, a, a, 180, 90);
        g.fillArc(0, b, a, a, 0, 90);
        g.setColor(Color.red);
        g.fillArc(-b, 0, a, a, 0, -90);
        g.fillArc(b, 0, a, a, 90, 90);
    }
}

एप्लेट: एक छोटा एप्लिकेशन प्रोग्राम जिसे किसी अन्य एप्लिकेशन में काम करते समय उपयोग के लिए कॉल किया जा सकता है।

उदाहरण छवि:

स्पष्टीकरण:

यह प्रत्येक टाइल को प्रिंट करने के लिए एक विधि का उपयोग करके काम करता है। विधि बनाने से पहले, इसे एक ग्राफिक्स ऑब्जेक्ट दिया जाता है जो प्रत्येक टाइल के ऊपरी बाएं कोने पर केंद्रित एक समन्वय प्रणाली का उपयोग करता है:

एक टाइल बनाने के लिए, हम निम्नलिखित विधि का उपयोग करते हैं:

void a(Graphics g, int c) {
    g.setColor(Color.red);
    g.fillRect(0, 0, b, b);
    g.fillRect(b, b, b, b);
    g.setColor(Color.blue);
    g.fillRect(b, 0, b, b);
    g.fillRect(0, b, b, b);
    g.fillArc(0, -b, a, a, 180, 90);
    g.fillArc(0, b, a, a, 0, 90);
    g.setColor(Color.red);
    g.fillArc(-b, 0, a, a, 270, 90);
    g.fillArc(b, 0, a, a, 90, 90);
}

हालांकि, सही छवि बनाने के लिए हर दूसरी टाइल को क्षैतिज रूप से परिलक्षित किया जाना चाहिए।

एक टाइल को प्रतिबिंबित करने के लिए, हम केवल graphicsइस कोड के साथ आपूर्ति की गई वस्तु को संशोधित करते हैं :

g.translate(a, 0);
((Graphics2D) g).scale(-1, 1);

धन्यवाद @CoolGuy 4 बाइट्स के लिए।

Comments

आप इसे घोषित करके xऔर yवर्ग के क्षेत्रों के रूप में इसे और अधिक गोल्फ कर सकते हैं :int a = 98, b = 49,x,y;

— स्पिकैट्रिक्स

Answer 9

गणितज्ञ 299 256

Wordy लेकिन यह पता लगाने के लिए अच्छा था।

मूल टाइल आर (नीचे दिखाया गया है) है, जो कि रीजनल प्लॉट द्वारा प्रदर्शित क्षेत्र है। टाइल का एक बायां-दायां प्रतिबिंब बनता है और आर के साथ जुड़ जाता है। दो टाइल इकट्ठे आकृति को फिर अंतरिक्ष में टाइल करने के लिए दोहराया जाता है।

a_~f~b_ := (x + a)^2 + (y + b)^2 <= 1;
a = ImageAssemble;
r = RegionPlot[(0~f~0 && y <= 0 && ! f[-1, 1]) \[Or] (0~f~2 && 
      y >= -2 && ! f[1, 1]), {x, -1, 1}, {y, -2, 0}, Frame -> False,
    BoundaryStyle -> None];
s = ImageCrop@Rasterize@r;
t = s~ImageReflect~Right;
i = a@{s, t};
j = a@{t, s};
a@{k = {i, i, i, i}, m = {j, j, j, j}, k, m, k, m}

Answer 10

सी, 237 209 180 बाइट्स

180 बाइट्स। इस संस्करण में एक टिप्पणी में edc65 द्वारा सुझाए गए परिवर्तन शामिल हैं। यह मैक पर निर्माण करते समय 9 संकलक चेतावनी देता है और क्लैंग और डिफ़ॉल्ट विकल्पों के साथ:

a,b,c,d,x,y;main(){for(puts("P1 256 256");b=a+32&64,a<256;++a){for(c=0;d=c+32&64,x=(a&64)-d?31-a&31:a&31,y=(c&64)-b?c&31:31-c&31,c++<256;)putchar(48+(x*x+y*y<962^b==d));puts("");}}

मार्टिन द्वारा टिप्पणियों के कुछ सुझावों का उपयोग करते हुए 209 बाइट्स। क्लैंग के साथ चेतावनी के बिना संकलन:

#include <stdio.h>
int a,b,c,d,x,y;int main(){puts("P1 256 256");for(;b=a+32&64,a<256;++a){for(c=0;d=c+32&64,x=(a&64)-d?31-a&31:a&31,y=(c&64)-b?c&31:31-c&31,c<256;++c)putchar(48+(x*x+y*y<962^b==d));puts("");}}

मूल संस्करण, 237 बाइट्स:

#include <stdio.h>
int main(){puts("P1 256 256");for(int a=0;a<256;++a){int b=a+32&64;for(int c=0;c<256;++c){int d=c+32&64;int x=(a&64)-d?31-a&31:a&31;int y=(c&64)-b?c&31:31-c&31;putchar(48+(x*x+y*y<962^b==d));}puts("");}}

परिणाम (256x256):

बेहतर पठनीयता के लिए व्हाट्सएप के साथ मूल कोड:

#include <stdio.h>
int main()
{
    puts("P1 256 256");
    for (int a = 0; a < 256; ++a)
    {
        int b = a + 32 & 64;
        for (int c = 0; c < 256; ++c)
        {
            int d = c + 32 & 64;
            int x = (a & 64) - d ? 31 - a & 31 : a & 31;
            int y = (c & 64) - b ? c & 31 : 31 - c & 31;
            putchar(48 + (x * x + y * y < 962 ^ b == d));
        }
        puts("");
    }
}

यह किसी भी ग्राफिक्स लाइब्रेरी का उपयोग नहीं करता है, रेंडरिंग पूरी तरह से कोड में निहित है।

मूल विचार केवल सभी 256x256 पिक्सेल पर लूप करना है, और देखें कि क्या वे 32x32 उप-वर्ग के गोलाकार चाप के अंदर / बाहर हैं जो अंदर हैं। समग्र पिक्सेल निर्देशांक के निचले 5 बिट्स पिक्सेल के सापेक्ष निर्देशांक को परिभाषित करते हैं। उप-वर्ग। (x, y)त्रिज्या के साथ चाप के अंदर होने का अंदर / बाहर का परीक्षण rफिर मानक है:

x * x + y * y < r * r

अधिकांश तर्क उप-वर्ग के सही कोने में चाप के केंद्र को रखने के लिए है, और यह निर्धारित करना है कि कौन सा रंग अंदर / बाहर है।

समाधान पर कुछ टिप्पणियां:

• कोड PBM ASCII प्रारूप में छवि उत्पन्न करता है। मैंने परिणाम को GIMP में लोड किया, और मैंने जो वास्तविक फ़ाइल यहां पोस्ट की, उसे जेनरेट करने के लिए पेंट में एक कॉपी और पेस्ट किया। इसलिए प्रारूप को रूपांतरित किया गया था, लेकिन सामग्री मूल आउटपुट के समान है।
• यदि आप बारीकी से देखते हैं, तो आप देख सकते हैं कि गुणवत्ता महान नहीं है। ऐसा इसलिए है क्योंकि पिक्सेल केंद्र के बजाय पिक्सेल के कोने के लिए अंदर / बाहर की गणना की जाती है, जिससे पूरी चीज़ 1/2 पिक्सेल बंद हो जाती है। मुझे नहीं लगता कि बेहतर करना बहुत मुश्किल होगा, लेकिन यह कोड को कुछ लंबा कर देगा। और चूंकि विशिष्ट गुणवत्ता की आवश्यकताएं नहीं थीं, मेरा मानना ​​है कि यह पर्याप्त है।
• एक मैक पर क्लैंग का उपयोग करके कोड संकलित किया गया था। नवीनतम संस्करण चेतावनी देता है, प्रारंभिक संस्करण नहीं था।
• यह पहली बार है जब मैंने कभी इनमें से किसी एक का प्रयास किया, इसलिए मैंने संभवत: अंतिम बाइट को बचाने के लिए कुछ तरकीबें याद कीं।

Comments

PPCG में आपका स्वागत है! मैं एक बड़ा सी गोल्फर नहीं हूं, लेकिन मुझे लगता है कि मैं कुछ सुधार देख सकता हूं: अपनी घोषणाओं को समूह बनाइए int a,b,c,d,x,y;... मुझे लगता है कि आप यहां तक main(a,b,c,d,x,y)कि मुझे कुछ याद रखने में सक्षम हो सकते हैं कि डिफ़ॉल्ट प्रकार इंट है। एक बार जब आप उससे छुटकारा पा लेते हैं, तो आप असाइनमेंट्स को d, x और y में ले जा सकते हैं जैसे कि आंतरिक forवृद्धि विवरण d=c+32&64,...,++c(शायद ++किसी अन्य स्थान पर भी स्थानांतरित करें जहां आप कहीं cभी उल्लेख करते हैं ), और फिर आप के ब्रेसेस को छोड़ सकते हैं भीतरी for। अच्छा काम है, btw! :)

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

धन्यवाद! मैंने युक्तियों की सूची में बिना किसी प्रकार के तर्क के घोषणा के साथ चाल देखी, लेकिन यह इतना गंदा लग रहा था कि मैं खुद वहां जाने के लिए तैयार नहीं हो पाया। ;) मुझे नहीं लगता कि मानक मानक के लिए गैर-मानक तर्क होना main()। मुझे निश्चित रूप से घोषणाओं का समूह बनाना चाहिए। और वेतन वृद्धि से बाइट के एक जोड़े को भी बचाया जा सकेगा। puts()न्यू लाइन के लिए बाहरी पाश में है, इसलिए मुझे यकीन है कि नहीं कर रहा हूँ अगर मैं ब्रेसिज़ से छुटकारा मिल सकता है।

— रेटो कोराडी

जब तक यह कुछ सामान्य संकलक में संकलित होता है, तब तक हम आम तौर पर इसके साथ ठीक होते हैं (इसलिए इसका पूरी तरह से मानक सी नहीं होना चाहिए)। इसके अलावा, मुझे नहीं लगता कि आप बाहरी ब्रेसिज़ से छुटकारा पा सकते हैं, लेकिन आपको सक्षम होना चाहिए, आंतरिक लोगों को दूर करने के लिए।

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

इसे 210 बाइट्स के लिए मिला। विचारों के लिए धन्यवाद।

— रेटो कोराडी

संकेत: stdioआवश्यक नहीं, फ़ंक्शन की डिफ़ॉल्ट घोषणा का उपयोग करें। intग्लोबल्स के लिए डिफ़ॉल्ट है और छोड़ा जा सकता है (चर और मुख्य)। पहले putsके लिए अंदर जा सकते हैं। सी लूप का उपयोग आंतरिक लूप के अंदर नहीं किया जाता है, इसलिए स्थिति में वृद्धि। 180: a,b,c,d,x,y;main(){for(puts("P1 256 256");b=a+32&64,a<256;++a){for(c=0;d=c+32&64,x=(a&64)-d?31-a&31:a&31,y=(c&64)-b?c&31:31-c&31,c++<256;)putchar(48+(x*x+y*y<962^b==d));puts("");}}(कई चेतावनियों के साथ संकलन करता है लेकिन चलता है)

— edc65