আমি আমার অ্যাটিক উইন্ডোটি থেকে আমার প্রতিবেশীর উঠোনের দিকে তাকিয়ে আছি। তাদের উঠোনটির মাঝখানে একটি কুকুরের শিকল রয়েছে। কুকুরটি ইয়ার্ডের চারপাশে ছুটে যায় তবে সর্বদা তার চেইনের শেষে থাকে, তাই এটি ময়লা ফেলার একটি ট্র্যাক রেখে শেষ হয়। সাধারণত এই ট্র্যাকটি পুরোপুরি বিজ্ঞপ্তিযুক্ত হবে, তবে আমার প্রতিবেশীদের কাছে তাদের উঠোনে আরও কিছু খুঁটি রয়েছে যা কুকুরের শৃঙ্খলে ধরা পড়ে। প্রতিবার কুকুরের শৃঙ্খলটি একটি মেরুতে আঘাত করে কুকুরটি নতুন মেরুটি ঘুরতে শুরু করে যা পরিমাণ চেইনের দৈর্ঘ্যকে তার ব্যাসার্ধ হিসাবে রেখে দেয় with যেহেতু খুঁটি, কুকুর এবং শৃঙ্খলা সবই শূন্য প্রস্থে রয়েছে (আমার প্রতিবেশীরা গণিতবিদ) চেনটি বৃত্তের সংক্ষিপ্তার ব্যাসার্ধ ছাড়াই অনির্দিষ্টকালের জন্য একটি মেরুর চারদিকে বাতাস করতে পারে। কুকুরটি চেইনটি (কেবল তার কলার নয়) দিয়েও যেতে পারে যদি চেইনটি তার পথে থাকে। এই অদ্ভুততাটি কিছুক্ষণ পর্যবেক্ষণ করার পরে আমি স্থির করি যে আমি আমার প্রতিবেশীর কুকুরের অনুকরণের জন্য কিছু কোড লিখব। কোডটি একটি কেন্দ্রের খুঁটির অবস্থান গ্রহণ করবে, যেখানে কুকুরটিকে বেঁধে রাখা হয়েছে, আমার প্রতিবেশী আঙ্গিনায় থাকা অন্যান্য খুঁটির অবস্থান, শৃঙ্খলার দৈর্ঘ্য এবং কুকুরের প্রারম্ভিক অবস্থান এবং এই চিত্রটি নির্দেশ করে একটি চিত্র নির্ধারণ করবে পথ যেখানে কুকুর ঘাস নিচে পড়েছে। আপনি ধরে নিতে পারেন যে নীচের যে কোনও সংমিশ্রণ স্থির (এবং এগুলি এটিকে ইনপুট হিসাবে গ্রহণ করবেন না):

কুকুরটিকে বেঁধে দেওয়া মেরুটির অবস্থান
চেইনের দৈর্ঘ্য
কুকুরের অবস্থান শুরু হচ্ছে

সূর্য উঠছে, তাই আমার অ্যাটিকের মেঝেতে জানালা দিয়ে আলোকিত স্থানটি সঙ্কুচিত হচ্ছে, আমাকে আমার কোড লেখার জন্য কম এবং কম স্থান দিচ্ছে। দয়া করে আপনার কোডের বাইট গণনাটি ছোট করার চেষ্টা করুন যাতে আমার এটিক ফ্লোরে এটি খসড়া করার জায়গা থাকে।

পরীক্ষার মামলা

এখানে আমি ধরে নিয়েছি যে কুকুরটি এটিতে অবস্থিত কোন মেরু থেকে বেঁধে রাখা (লাল বিন্দু) থেকে 3 ইউনিট দক্ষিণে শুরু করে 0,0। স্পষ্টতার জন্য খুঁটিগুলি যেখানে বিন্দুগুলির সাথে রয়েছে তা আমি নির্দেশ করেছি, আপনার সেগুলিকে আপনার আউটপুটে অন্তর্ভুক্ত করার দরকার নেই।

Poles at 1,2 -1,2

Poles at 0,.5

Poles at 0,1 1,1 -2,1 -1,-.5

Poles at 0,1 1,1

— গম উইজার্ড
সূত্র

আউটপুট কি জন্য {0,-.5}?

— ক্রিটিকি লিথোস

@ ক্রিতিক্সিলিথোস এর আউটপুট {0,.5}বৃহত্তম বৃত্ত ছাড়াই উল্লম্বভাবে উল্টে গেছে। কুকুরটি মূলত দ্বিতীয় মেরুতে ধরা শুরু করে।

— গম উইজার্ড

ভাসমান-পয়েন্ট সমস্যার ফলস্বরূপ, আমার প্রোগ্রামটি শেষ টেস্টকেস (স্ট্রিংয়ের দৈর্ঘ্য 99.99999) এর চারপাশে (1,1) একটি বৃত্ত আঁকবে। এটা ঠিক আছে?

— ক্রিটসি লিথোস

কুকুরটি ঘড়ির কাঁটা এবং পাল্টা-ঘড়ির কাঁটা দুটোই চালায়, তবে একটি নির্দিষ্ট বিন্দু থেকে?

— ব্যবহারকারী 202729

3

"উইন্ডো দ্বারা আলোকিত আমার অ্যাটিকের মেঝেতে সূর্য বাড়ছে এবং সঙ্কুচিত হচ্ছে আমার কোড লেখার জন্য কম এবং কম স্থান দিচ্ছে" +1

— লিও

11

পাইথন 3 ম্যাটপ্ল্লোব, 457 বাইট ব্যবহার করে

from cmath import*
from matplotlib import pyplot as g,patches as i
def x(p):
 p+=[0];d=180/pi;a=2;h=g.gca();h.set_xlim(-5,5);h.set_ylim(-5,5)
 while a:
  a-=1;c=0;y=3;z=-pi/2
  while 1:
   s=[n for n in p if abs(n-c)<=y and n!=c]
   if not s:h.add_patch(i.Arc((c.real,c.imag),y*2,y*2));break
   n=[max,min][a](s,key=lambda n:(z-phase(n-c))%(2*pi));l,r=polar(n-c);h.add_patch(i.Arc((c.real,c.imag),y*2,y*2,[z,r][a]*d,0,[r-z,z-r][a]*d));y-=l;z=r;c=n
 g.show()

কারণ আপনার প্রতিবেশীরা গণিতবিদ, আমি ধরে নিয়েছি যে আপনার প্রতিবেশীর বাগান জটিল ডোমেন দখল করেছে এবং বাগানের কোনও বস্তুর সমন্বয়কারী জটিল সংখ্যা। এই ফাংশনটি ব্যবহার করার জন্য, আপনার প্রতিবেশীর বাগানের খুঁটির অবস্থানগুলি বোঝায় এমন জটিল সংখ্যার একটি তালিকা এটি পাস করা উচিত। ডিফল্ট স্থানাঙ্ক সিস্টেমের উপস্থাপনাটি বেছে নেওয়া হয়েছে, যেখানে ডানদিকে ইতিবাচক আসল সংখ্যা এবং উপরের দিকটি ইতিবাচক কাল্পনিক সংখ্যা। এর অর্থ উদাহরণগুলি হয়ে ওঠে:

x([2j+1,2j-1])
x([.5j])
x([1j,1+1j,-2+1j,-1-.5j])
x([1j,1+1j])

তদ্ব্যতীত, প্রোগ্রামটি নিম্নলিখিত বিষয়গুলি ধরে নিয়েছে: পীড়নটি 0 পয়েন্টের সাথে বেঁধে রাখা হয়েছে, পীড়নটি 3 ইউনিট দীর্ঘ এবং প্লটের ক্ষেত্রফল 10 দ্বারা 10 কেন্দ্রিক হয় 0 প্রায় এই পরামিতিগুলির জন্য, ফলাফলগুলি উদাহরণগুলির সাথে ঠিক মেলে, এবং ফলাফলটি দেখতে কেমন লাগে (চূড়ান্ত উদাহরণের জন্য):

অ্যালগরিদমটি বেশ সহজ, কেবলমাত্র একটি শর্তসাপেক্ষে ঘড়ির কাঁটার বিপরীতে এবং ঘড়ির কাঁটার বিপরীতে অনুসন্ধানের প্রয়োজন হয়। অ্যালগরিদমের অবস্থা বর্তমান আবর্তন বিন্দুতে আঘাত হানার সাথে সাথে বর্তমান ঘূর্ণন বিন্দু এবং লীজগুলির স্থিতিবিন্যাস / অবশিষ্ট দৈর্ঘ্য দ্বারা সংজ্ঞায়িত করা হয়। এটি নিম্নলিখিত হিসাবে কাজ করে:

সংঘর্ষ সেট থেকে পয়েন্টগুলি ফিল্টার আউট যা অবশিষ্ট ঘাট দৈর্ঘ্যের পাশাপাশি বর্তমান ঘূর্ণন বিন্দুর চেয়ে বর্তমান রোটেশন পয়েন্ট থেকে আরও দূরে রয়েছে।
যদি এই সেটটি খালি থাকে তবে এই বাহুর শেষটি পৌঁছে যাওয়ার সাথে সাথে এই পয়েন্টটির চারপাশে অবশিষ্ট বেল্ট দৈর্ঘ্যের ব্যাসার্ধের সাথে একটি বৃত্ত আঁকুন।
পয়েন্টটি নির্ধারণ করুন যেখানে পার্থক্য ভেক্টর এবং ল্যাশ ওরিয়েন্টেশনের মধ্যে পর্বের পার্থক্যটি ন্যূনতম / সর্বাধিক। এটি পরের পয়েন্টটি যথাক্রমে ঘড়ির কাঁটা / ঘড়ির কাঁটার দিক দিয়ে আঘাত করবে।
এই ভেক্টরগুলির উপর ভিত্তি করে চাপটি আঁকুন, ল্যাশ দৈর্ঘ্যটি ধরুন, দূরত্বের প্রস্থকে বিয়োগ করুন এবং পার্থক্য ভেক্টরের অভিমুখীকরণের জন্য ল্যাশ ওরিয়েন্টেশনটি সেট করুন। রোটেশন পয়েন্ট আপডেট করুন এবং শুরু থেকে চালিয়ে যান।

এরপরে এই অ্যালগরিদমটি প্রথমে ঘড়ির কাঁটার দিক থেকে সঞ্চালিত হয়, তার পরে রাষ্ট্রটি পুনরায় সেট করা হয় এবং এটি পাল্টা দিকের দিক দিয়ে চালানো হয়। অ্যালগরিদমের সরলতার অর্থ হল প্রোগ্রামের বাইকাউন্টের প্রায় অর্ধেকটি অঙ্কন ফাংশনে ব্যয় করা হয়। যদি অঙ্কনের রুটিনগুলি কেটে ফেলা হয় তবে এটি প্রোগ্রামের আকার থেকে 218 বাইট সরিয়ে ফেলবে।

নিম্নলিখিতটি একটি অবারিত সংস্করণ যা ডিবাগ কোডও ধারণ করে যা পয়েন্ট এবং ল্যাশ সংঘর্ষগুলিও প্রদর্শন করে:

from cmath import pi, rect, polar, phase
from matplotlib import pyplot, patches
def x_ungolfed(points):
    degrees = 180/pi # conversions

    # add the center point to the collision points
    points.append(0.0)

    # configure plot area
    axes=pyplot.gca()
    axes.set_xlim(-5,5)
    axes.set_ylim(-5,5)

    # plot the points
    x, y =zip(*((p.real, p.imag) for p in points))
    axes.scatter(x, y, 50, "b")

    # first iteration is clockwise, second counterclockwise
    clockwise = 2
    while clockwise:
        clockwise -= 1

        # initial conditions
        center = 0 + 0j;
        leash_size = 3
        leash_angle = -pi / 2

        # initial leash plot
        leash_start = rect(leash_size, leash_angle)
        axes.plot([center.real, leash_start.real], [center.imag, leash_start.imag], "r")

        # search loop
        while 1:
            # find possible collission candidates
            candidates = [n for n in points if abs(n - center) <= leash_size and n != center]
            # if we reached the end, draw a circle
            if not candidates:
                axes.add_patch(patches.Arc(
                    (center.real, center.imag), 
                    leash_size*2, leash_size*2
                ))
                break
            # find the actual collision by comparing the phase difference of the leash angle vs the difference between the candidate and the current node
            new = (min if clockwise else max)(candidates, key=lambda n: (leash_angle - phase(n - center)) % (2 * pi))

            # convert the difference to polar coordinates
            distance, new_angle = polar(new - center)
            # draw the arc
            if clockwise:
                axes.add_patch(patches.Arc(
                    (center.real, center.imag),
                    leash_size * 2, leash_size * 2,
                    new_angle * degrees,
                    0,
                    (leash_angle-new_angle) * degrees
                ))
            else:
                axes.add_patch(patches.Arc(
                    (center.real, center.imag),
                    leash_size * 2, leash_size * 2,
                    leash_angle * degrees,
                    0,
                    (new_angle - leash_angle) * degrees
                ))
            # draw intermediate lines
            edge = rect(leash_size, new_angle) + center
            axes.plot([center.real, edge.real], [center.imag, edge.imag], "g")

            # perform updates: decrease remaining leash size, set new leash angle, move rotation center to the collision
            leash_size -= distance
            leash_angle = new_angle
            center = new

    # show the graph
    pyplot.show()

এটি উত্পাদিত আউটপুটটি দেখতে এইরকম দেখাচ্ছে:

— CensoredUsername
সূত্র

সত্যিই দুর্দান্ত ব্যাখ্যার জন্য এবং আমাকে প্রায় দ্বিগুণ দ্বিগুণ করে গল্ফ করেছেন! <s> গোশ আমি সেই বিল্টিনগুলিকে vyর্ষা করি </ s>

— ক্রিটকি লিথোস

7

প্রসেসিং 3, 815 833 835 876 879 বাইট

অপ্রয়োজনীয় প্রথম বন্ধনী অপসারণ করে @ জাচারিটির কাছে দুটি বাইট সংরক্ষণ করা হয়েছে

void settings(){size(600,600);}int i,w,x,n;float l,d,t,a,f,g,m,R,U;float[][]N,T;float[]S,p;void s(float[][]t){N=new float[t.length+1][2];N[0][0]=N[0][1]=i=0;for(float[]q:t)N[++i]=q;translate(w=300,w);noFill();pushMatrix();f(N,0,-w,w,1,0);popMatrix();f(N,0,-w,w,0,0);}float p(float a,float b){for(a+=PI*4;a>b;)a-=PI*2;return a;}void f(float[][]P,float x,float y,float L,int c,int I){l=2*PI;d=i=0;S=null;for(;i<P.length;i++){float[]p=P[i];g=atan2(y,x);m=atan2(p[1],p[0]);if(p(f=(c*2-1)*(g-m),0)<l&(t=dist(0,0,p[0],p[1]))<=L&I!=i){l=p(f,0);S=new float[]{g,m};d=t;n=i;}}if(S==null)ellipse(0,0,2*(L-d),2*(L-d));else{arc(0,0,L*2,L*2,p(S[c],S[1-c]),S[1-c]);R=cos(a=S[1]);U=sin(a);translate(d*R,d*U);T=new float[P.length][2];for(int i=0;i<T.length;T[i][1]=P[i][1]-d*U,i++)T[i][0]=P[i][0]-d*R;f(T,(L-d)*R,(L-d)*U,L-d,c,n);}}

এই প্রোগ্রামটি এভাবে চালান:

void setup() {
    s(new float[][]{{0,100},{100,100},{-200,100},{-100,-50}});
}

(ফাংশনটি sএকটি গ্রহণ করে float[][])। এটি মূলত টেস্টকেস # 3, তবে উইন্ডো ফিট করার জন্য 100 দ্বারা গুণিত।

কয়েকটি বিষয় লক্ষণীয়:

প্রোগ্রামটি খুঁটি আঁকা না
চিত্রগুলি উল্টাপাল্টিতে উল্টে যায় কারণ প্রসেসিংয়ের সমন্বয় ব্যবস্থাতে ধনাত্মক y- অক্ষ নিচে চলে যায়
প্রসেসিং ফ্লোট ব্যবহার করে বলে, গণনাগুলি খুব সঠিক নয়, তাই আপনি এটি চিত্রগুলিতে দেখতে পাবেন। আমি ওপিকে জিজ্ঞাসা করেছি যদি এই ভাসমান-পয়েন্ট ত্রুটিযুক্ত বিষয়।
উইন্ডোর আকার 600 পিক্সেল বাই 600 পিক্সেল
খুব ছোট ইনপুট স্থানাঙ্কগুলি প্রোগ্রামটিকে উদ্বুদ্ধ করবে কারণ স্ট্যাক pushMatrix()এবং popMatrix()অপারেটিং কেবল 32 ম্যাট্রিক রাখতে পারে।
কুকুরটি শুরু হয় (0, -300) এবং চেইনটি 300 পিক্সেল দীর্ঘ থেকে শুরু হয়
সুবিধার জন্য নীচের চিত্রগুলি ছোট করা হয়েছে

উপরের টেস্টকেসের জন্য নমুনা আউটপুট।

আপনি যদি পূর্বনির্ধারিত আউটপুট দেখতে চান তবে translate(w,w);ফাংশনটির ঠিক পরে এই লাইনটি যুক্ত করুন s।

background(-1);scale(1,-1);fill(255,0,0);ellipse(0,0,25,25);fill(0);for(float[]q:N)ellipse(q[0],q[1],25,25);

এবং এটি আমাদের এই ফলাফল দেয়:

অবহেলিত `f()`এবং ব্যাখ্যা

(পাশাপাশি ডিবাগ কোড রয়েছে)

void f(float[][]points, float x, float y, float len, int c, int pindex) {
    print(asd+++")");
    float closest = 2*PI;
    float d=0,t;
    float[]stuff = null;
    int index = 0;
    for(int i=0;i<points.length;i++) {
        if(pindex != i) {
            float[]p = points[i];
            float originAngle = atan2(y, x);
            float tempAngle = atan2(p[1], p[0]);
            //println(x,y,p[0],p[1]);
            float diff = c<1?tempAngle-originAngle:originAngle-tempAngle;
            println("@\t"+i+"; x=\t"+x+"; y=\t"+y+"; tx=\t"+p[0]+"; ty=\t",p[1], diff, originAngle, tempAngle);
            if(p(diff) < closest && (t=dist(0,0,p[0],p[1])) < len) {
                println("+1");
                closest = p(diff);
                stuff = new float[]{originAngle, tempAngle};
                d=t;
                index = i;
            }
        }
    }
    if(stuff == null) {
        ellipse(0,0,2*(len-d),2*(len-d));
        println("mayday");
    } else {
        println("d angles",d,p(stuff[c],stuff[1-c],c), stuff[1-c]);
        //println(points[0]);
        arc(0, 0, len*2, len*2, p(stuff[c],stuff[1-c],c), stuff[1-c]);
        float angle = stuff[1];
        translate(d*cos(angle), d*sin(angle));
        println("Translated", d*cos(angle), d*sin(angle));
        println("angle",angle);
        float[][]temp=new float[points.length][2];
        for(int i=0;i<temp.length;i++){
            temp[i][0]=points[i][0]-d*cos(angle);
            temp[i][1]=points[i][1]-d*sin(angle);
            println(temp[i]);
        }
        println(d*sin(angle));
        pushMatrix();
        println();
        f(temp, (len-d)*cos(angle), (len-d)*sin(angle), (len-d), c, index);
        popMatrix();
        //f(temp, (len-d)*cos(angle), (len-d)*sin(angle), (len-d), 0, index);
    }
}

এটি শীঘ্রই রাখতে, প্রোগ্রামটি দুটি "সিক্সার" প্রেরণ করে, একটিটি ঘড়ির কাঁটার বিপরীতে যায় এবং অন্যটি ঘড়ির কাঁটার দিকে। এই সন্ধানকারীদের প্রত্যেকটি নিকটতম মেরুটি খুঁজে পায় এবং এটিতে একটি চাপ দেয় যদি চেইনটি দীর্ঘ হয় তবে অন্যভাবে বিজ্ঞ এটি বৃত্ত আঁকেন। একবার এটি একটি চাপ তোলার পরে এটি অন্য একজন সন্ধানকারীকে সেই মেরুতে প্রেরণ করে এবং প্রক্রিয়াটি অব্যাহত থাকে। f()প্রতিটি সন্ধানকারী প্রক্রিয়া থাকে। আমি আরও গল্ফ করার সাথে সাথে আরও বিস্তারিত ব্যাখ্যা আসবে।

— ক্রিটসি লিথোস
সূত্র

আপনার কি শেষের দিকে পেরেন্স দরকার L-d?

— জাকারি

@ জাচারি আমি জানি না যে আমি কীভাবে মিস করেছি, ধন্যবাদ।

— ক্রিটসি লিথোস

5

লোগো, 305 298 297 293 বাইট

এফএমএসলোগোতে কোডটি চেষ্টা করে দেখুন।

একটি ফাংশন draw(হিসাবে গল্ফড d) সংজ্ঞায়িত করুন যা মেরু স্থানাঙ্কের একটি তালিকা হিসাবে ইনপুট দেওয়া হয়েছে (উদাহরণস্বরূপ draw [[0 100] [100 100] [-200 100] [-100 -50][0 0]], স্ক্রিনে ফলাফলটি আঁকবে)।

প্রয়োজনীয়তা:

প্রাথমিক দড়ি দৈর্ঘ্য = 300 পিক্সেল। (3 পিক্সেল খুব ছোট হিসাবে)
[0 0]পোল তালিকায় অবশ্যই অন্তর্ভুক্ত থাকতে হবে। যদি ডিবাগ কোড (আঁটি খুঁটি) চালু থাকে তবে [0 0]অবশ্যই শেষ আইটেমটি হওয়া উচিত।
কুকুরটি স্থানাঙ্কিতে শুরু হয় x=0, y=-300(সমস্যার বিবরণ হিসাবে)

সম্ভাব্য অপ্টিমাইজেশন:

-1 বাইট যদি ব্যতিক্রমী ক্ষেত্রে (ক মেরু মধ্যে কুকুর রান) প্রতিস্থাপন গাণিতিকভাবে সঠিক হতে প্রয়োজন হয় না >=সঙ্গে>

গল্ফ কোড:

to f
op(if ?=pos 360 modulo :m*(180+heading-towards ?)360)
end
to x :m[:1 300]
home
forever[make 2 filter[:1>=u ?](sort :p[(u ?)<u ?2])invoke[pd
arc -:m*f :1
pu
if 360=f[stop]make 1 :1-u ?
lt :m*f
setpos ?]reduce[if f<invoke[f]?2[?][?2]]:2]
end
to d :p
copydef "u "distance
foreach[1 -1]"x
end

অবহেলিত কোড ( ;একটি ইনলাইন মন্তব্য শুরু করে (ব্যাখ্যা করার জন্য ব্যবহৃত হয়), এবং :একটি পরিবর্তনশীল নাম শুরু করে):

to f
    op ifelse ? = pos 360 modulo :m*(180 + heading - towards ?) 360
end

to x
    home
    foreach :poles [pu setpos ? pd circle 5] ; debug code
    make "length 300 ; initial length of rope
    forever [
        make "tmp filter [:length >= distance ?] ; floating point error makes > and >= similar,  ~
            ; but >= is correct mathematically ~
            (sort :poles [(distance ?) < distance ?2])
         ; the last = longest element will be rotated
        invoke [
            pd
            arc -:m*f :length
            pu
            if 360=f [stop]
            make "length :length - distance ?
            lt :m*f
            setpos ?
        ] reduce [
            if f < invoke[f]?2 [?] [?2]
        ] :tmp ; apply to use ? instead of :pos
    ]
end

to draw :poles
    foreach [1 -1] [[m]
        x
    ]
end

— user202729
সূত্র

1

পাইথন 2 + পিআইএল, 310 বাইট

from PIL import Image
from cmath import*
I,_,X,P=Image.new('1',(300,300),'white'),abs,polar,input()
def r(s):
 a,C,l=0,0,3
 while _(a)<99:
  c=C+l*exp(1j*a);I.load()[c.real*30+150,150-c.imag*30]=0
  for p in P+[0]:
   N,E=X(C-c);n,e=X(C-p)
   if n<=N and _(E-e)<.1:l-=_(p-C);C=p
  a+=s
r(.01)
r(-.01)
I.show()

স্ক্রিপ্টটি জটিল সংখ্যার তালিকা হিসাবে স্টিডিনের পয়েন্টগুলির তালিকাটি পড়ে।

printf '[complex(0,0.5)]' | python2 snippet.py

printf '[complex(0,1), complex(1,1)]' | python2 snippet.py

— Dieter
সূত্র

একটি চেইন উপর একটি কুকুর