2 ডি সংঘর্ষ সনাক্তকরণ

এই চ্যালেঞ্জটি আমাকে সম্প্রতি একটি সাধারণ গেমের জন্য লিখতে হয়েছিল এমন প্রকৃত সংঘর্ষ সনাক্তকরণের ভিত্তিতে।

এমন একটি প্রোগ্রাম বা ফাংশন লিখুন যা দুটি বস্তু প্রদত্ত হয়ে দুটি বস্তুর সংঘর্ষে রয়েছে (যেমন ছেদ করে) বা না হয় তার উপর নির্ভর করে সত্যবাদী বা মিথ্যা মান দেয় ।

আপনাকে তিন ধরণের অবজেক্টকে সমর্থন করতে হবে:

লাইন বিভাগ : দুটি সমাপ্তি নির্দেশক, অর্থাৎ (x ₁ , y ₁ ) এবং (x ₂ , y ₂ ) 4 টি ভাসমান দ্বারা প্রতিনিধিত্ব করা হয় । আপনি ধরে নিতে পারেন যে শেষের পয়েন্টগুলি অভিন্ন নয় (সুতরাং লাইন বিভাগটি অধঃপতন নয়)।
ডিস্ক : অর্থাত চেনাশোনা ভরা, 3 ভাসে, কেন্দ্র দুটি দ্বারা প্রতিনিধিত্ব (X, Y) ব্যাসার্ধ জন্য এবং এক (ধনাত্মক) দ ।
গহ্বর : এগুলি একটি ডিস্কের পরিপূরক। অর্থাৎ একটি গহ্বর একটি কেন্দ্র এবং ব্যাসার্ধ দ্বারা নির্দিষ্ট একটি বৃত্তাকার অঞ্চল ব্যতীত 2 ডি সমস্ত স্থান পূরণ করে।

আপনার প্রোগ্রাম বা ফাংশনটি সনাক্তকারী পূর্ণসংখ্যার আকারে (আপনার পছন্দের) এবং তাদের 3 বা 4 ফ্লোট আকারে এই জাতীয় দুটি বস্তু গ্রহণ করবে। আপনি STDIN, ARGV বা ফাংশন যুক্তির মাধ্যমে ইনপুট নিতে পারেন। আপনি যে কোনও সুবিধাজনক ফর্মের ইনপুটটি উপস্থাপন করতে পারেন যা প্রাক প্রসেস করা হয় না, যেমন 8 থেকে 10 টি পৃথক সংখ্যা, দুটি কমা-বিচ্ছিন্ন মান বা দুটি তালিকার তালিকা। ফলাফলটি STDOUT এ ফিরে বা লেখা যেতে পারে।

আপনি ধরে নিতে পারেন যে অবজেক্টগুলি হয় কমপক্ষে 10 ^-10 দৈর্ঘ্যের একক পৃথক হয় বা এতগুলি ছেদ করে, তাই আপনাকে ভাসমান পয়েন্টের ধরণের সীমাবদ্ধতা সম্পর্কে চিন্তা করার দরকার নেই।

এটি কোড গল্ফ, তাই সংক্ষিপ্ত উত্তরটি (বাইটে) জেতে।

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

তালিকাভিত্তিক ইনপুট ফর্ম্যাটটি ব্যবহার করে, এর 0সাথে ডিস্ক 1এবং গহ্বরগুলির সাথে লাইন বিভাগগুলিকে উপস্থাপন 2করে, নিম্নলিখিতগুলির মধ্যে একটি সত্যবাদী আউটপুট উত্পাদন করা উচিত:

[0,[0,0],[2,2]], [0,[1,0],[2,4]]        # Crossing line segments
[0,[0.5,0],[-0.5,0]], [1,[0,0],1]       # Line contained in a disc
[0,[0.5,0],[1.5,0]], [1,[0,0],1]        # Line partially within disc
[0,[-1.5,0.5],[1.5,0.5]], [1,[0,0],1]   # Line cutting through disc
[0,[0.5,2],[-0.5,2]], [2,[0,0],1]       # Line outside cavity
[0,[0.5,0],[1.5,0]], [2,[0,0],1]        # Line partially outside cavity
[0,[-1.5,0.5],[1.5,0.5]], [2,[0,0],1]   # Line cutting through cavity
[1,[0,0],1], [1,[0,0],2]                # Disc contained within another
[1,[0,0],1.1], [1,[2,0],1.1]            # Intersecting discs
[1,[3,0],1], [2,[0,0],1]                # Disc outside cavity
[1,[1,0],0.1], [2,[0,0],1]              # Disc partially outside cavity
[1,[0,0],2], [2,[0,0],1]                # Disc encircling cavity
[2,[0,0],1], [2,[0,0],1]                # Any two cavities intersect
[2,[-1,0],1], [2,[1,0],1]               # Any two cavities intersect

যদিও নিম্নলিখিতগুলির ফলস্বরূপ ফলাফল পাওয়া উচিত

[0,[0,0],[1,0]], [0,[0,1],[1,1]]        # Parallel lines
[0,[-2,0],[-1,0]], [0,[1,0],[2,0]]      # Collinear non-overlapping lines
[0,[0,0],[2,0]], [0,[1,1],[1,2]]        # Intersection outside one segment
[0,[0,0],[1,0]], [0,[2,1],[2,3]]        # Intersection outside both segments
[0,[-1,2],[1,2]], [1,[0,0],1]           # Line passes outside disc
[0,[2,0],[3,0]], [1,[0,0],1]            # Circle lies outside segment
[0,[-0.5,0.5],[0.5,-0.5]], [2,[0,0],1]  # Line inside cavity
[1,[-1,0],1], [1,[1,1],0.5]             # Non-intersecting circles
[1,[0.5,0],0.1], [2,[0,0],1]            # Circle contained within cavity

code-golf geometry decision-problem

— মার্টিন ইন্ডার
সূত্র

আমি প্রথমে ভেবেছিলাম এর চেয়ে কৌতুকময়। লাইন / লাইন কেস দিয়ে শুরু করে, আমি প্রান্তের মামলার এক বিস্ময়কর সংখ্যা নিয়ে এসেছি। আপনি কি কলাইনার অংশগুলিকে বাতিল করতে পারবেন না? জিনিসগুলি অনেক সহজ করে তুলবে। ;)

— এমিল 21

@ এমিল দুঃখিত, তবে পোস্ট করার 9 ঘন্টা পরে, আমি ধরে নিতে হবে যে অন্যরা চ্যালেঞ্জ নিয়ে কাজ শুরু করেছে, এবং স্পেক পরিবর্তন করা (ব্রেকিং সমস্যার সমাধান করা বাদে) আমার কাছে ভাল ধারণা বলে মনে হচ্ছে না। আপনি এটি কীভাবে করেন তার উপর নির্ভর করে, সমান্তরাল লাইন বিভাগগুলি কেবলমাত্র লাইন-লাইন সংঘর্ষগুলির জন্য আপনাকে চিন্তিত হওয়া উচিত though

— মার্টিন ইন্ডার

অবশ্যই, আপনি সত্যিই এটি পরিবর্তন করার প্রত্যাশা করছিলাম না। আমি মাত্র একটি ক্ষুদ্র কিছুটা হতাশ হয়েছি যে কলিনারি লাইনের বিভিন্ন বিভাগের বিভিন্ন রূপগুলি পরিচালনা করা আমার কোডটির দৈর্ঘ্য দ্বিগুণ করেছে। :) (উপায় দ্বারা একটি দুর্দান্ত চ্যালেঞ্জ!)

— এমিল 21

কোলাইনারি পয়েন্টগুলি "10 ^ -10 দ্বারা সংঘর্ষিত হয় না" এর নিচে পড়ে না?

— টুইনাইট

@ টুইনাট দু'টি লাইন কলাইনারি হলেও ওভারল্যাপ না হলে নয়। উদাহরণস্বরূপ[0,[-2,0],[-1,0]], [0,[1,0],[2,0]]

— মার্টিন ইন্ডার

উত্তর:

এপিএল, 279 208 206 203

s←1 ¯1
f←{x←⊣/¨z←⍺⍵[⍋⊣/¨⍺⍵]
2 2≡x:∧/0∧.=⌊(2⊃-⌿↑z)⌹⍣(≠.×∘⌽/x)⍉↑x←s×-/2⊢/↑z
2≡2⌷x:∨/((2⊃z)∇2,x[1]×(2⌷⊃z)+,∘-⍨⊂y÷.5*⍨+.×⍨y←⌽s×⊃-/y),x[1]=(×⍨3⊃⊃z)>+.×⍨¨y←(s↓⌽↑z)-2⌷⊃z
~x∨.∧x[1]≠(.5*⍨+.×⍨2⊃-⌿↑z)<-/⊢/¨z×s*1⌷x}

ফাংশনটিতে লাইন ব্রেকগুলি fস্পষ্টতার জন্য। তারা বিবৃতি বিভাজক সঙ্গে প্রতিস্থাপন করা উচিত⋄

আমি এত জটিল এপিএল প্রোগ্রামটি তৈরির পরে এত দিন হয়ে গেল। আমি মনে করি শেষ সময় ছিল এই কিন্তু আমি নিশ্চিত জটিল হিসাবে ছিল নই।

ইনপুট ফর্ম্যাটটি
মূলত ওপি হিসাবে একই, 0গহ্বর, 1ডিস্ক এবং 2লাইন বিভাগের জন্য ব্যবহার ব্যতীত ।

বড় আপডেট

আমি ভিন্ন অ্যালগরিদম ব্যবহার করে প্রচুর চরগুলি গল্ফ করতে সক্ষম হয়েছি। আর gষাঁড় নেই ** টি !!

মূল কাজটি fকেসগুলিতে বিভক্ত:

2 2≡x: বিভাগ-বিভাগ

এই ক্ষেত্রে, প্রতিটি লাইনের শেষ পয়েন্টগুলি থেকে ভেক্টরটি গণনা করুন এবং ভেক্টরগুলির মধ্যে ছেদটি অন্তর্ভুক্ত রয়েছে কিনা তা পরীক্ষা করতে লিনিয়ার সমীকরণগুলির একটি সিস্টেম সমাধান করুন।

আদেশ সহকারে:

কোনও ভেক্টরের শেষ পয়েন্টটি ভেক্টরের অংশ হিসাবে বিবেচনা করা হয় না (যদিও এটির উত্সটি রয়েছে)। তবে, যদি কেবল অন্য কোনও ভেক্টরের টিপ থাকে তবে অনুমান অনুযায়ী ইনপুটটি অবৈধ।
অ-অধঃপতিত সমান্তরাল বিভাগগুলি সর্বদা মিথ্যা প্রদান করে, কলিনারিটি নির্বিশেষে।
বিভাগগুলির মধ্যে একটি অবক্ষয়যুক্ত হলে সর্বদা মিথ্যা প্রত্যাবর্তন করুন। উভয় বিভাগ যদি অধঃপতিত হয় তবে সর্বদা সত্য আসুন।

উদাহরণ: (ডান দিকের চিত্রে ক্রিয়াকলাপ 1 দ্রষ্টব্য)

2≡2⌷x: বিভাগ-অন্যান্য

এই ক্ষেত্রে, অন্য বস্তুটি একটি বিজ্ঞপ্তিযুক্ত। বিভাগের শেষ পয়েন্টগুলি দূরত্বের চেক ব্যবহার করে বৃত্তের মধ্যে রয়েছে কিনা তা পরীক্ষা করুন।

ডিস্কের ক্ষেত্রে, প্রদত্ত বিভাগটির জন্য লম্ব ব্যাসের একটি লাইন বিভাগ তৈরি করুন। বিভাগগুলি পুনরাবৃত্তি দ্বারা সংঘর্ষ হয় কিনা তা পরীক্ষা করুন।
গহ্বরের ক্ষেত্রে, অবনমিত হওয়ার জন্য উল্লিখিত বিভাগটি নির্মাণে একটি "বার 0" এর দিকে ঝুঁকুন। (দেখুন কেন আমি এখন 0গহ্বর এবং 1ডিস্কের জন্য ব্যবহার করি ?) প্রদত্ত বিভাগটি অবনমিত না হওয়ায় বিভাগ-বিভাগের সংঘর্ষ সনাক্তকরণ সর্বদা মিথ্যা প্রত্যাবর্তন করে।

অবশেষে দূরত্বের পরীক্ষার ফলাফল এবং সংঘর্ষ সনাক্তকরণের ফলাফলগুলি একত্রিত করুন। গহ্বরের ক্ষেত্রে, দূরত্বের পরীক্ষার ফলাফলগুলি প্রথমে অগ্রাহ্য করুন। তারপরে (উভয় ক্ষেত্রে) বা 3 টি ফলাফল একসাথে

বিভাগ-বিভাগের সতর্কতা সম্পর্কিত, 3 নম্বর সম্বোধন করা হয় (এবং শোষণিত)। সংখ্যা 2 কোনও সমস্যা নয় কারণ আমরা এখানে লম্ব অংশগুলি ছেদ করছি, যা অবক্ষয় না হলে কখনও সমান্তরাল হয় না। নম্বর 1 কেবলমাত্র ডিস্ক ক্ষেত্রে কার্যকর হয়, যখন প্রদত্ত শেষ পয়েন্টগুলির মধ্যে একটি নির্মিত ব্যাসের উপর থাকে। শেষ পয়েন্টটি বৃত্তের ভিতরে ভাল থাকলে দূরত্বের চেকগুলি এটির যত্ন নেবে। যদি শেষ বিন্দুটি বৃত্তে থাকে, যেহেতু নির্মিত ব্যাসটি প্রদত্ত বিভাগের সমান্তরাল হয়, তবে পরবর্তীটি অবশ্যই ডিস্কের সাথে স্পর্শ করে কেবল একটি পয়েন্ট সহ বৃত্তের স্পর্শকাতর হতে হবে, যা বৈধ ইনপুট নয়।

উদাহরণ:

ডিফল্ট কেস: অন্যান্য-অন্যান্য

কেন্দ্রগুলির মধ্যে দূরত্ব গণনা করুন। ডিস্ক-ডিস্কের সংঘাত তখনই ঘটে যদি কেবলমাত্র দূরত্বের যোগফলের চেয়ে ছোট হয়। ডিস্ক-গহ্বরের সংঘর্ষ ঘটে এবং যদি কেবলমাত্র রেডিয়ির পার্থক্যের চেয়ে দূরত্ব বেশি হয়।

গহ্বর-গহ্বর কেসটির যত্ন নেওয়ার জন্য, দূরত্বের পরীক্ষার ফলাফলটিকে অগ্রাহ্য করুন এবং শনাক্তকরণের প্রতিটি পূর্ণসংখ্যার সাথে এবং তারপরে বা সেগুলি একত্রিত করুন। কিছু যুক্তি ব্যবহার করে, কেউ দেখায় যে এই প্রক্রিয়াটি যদি সত্য হয় এবং কেবলমাত্র যদি উভয়ই সনাক্তকারী পূর্ণসংখ্যাগুলি মিথ্যা (গহ্বর-গহ্বরের ক্ষেত্রে) হয়, বা দূরত্বের চেকটি সত্য হয় তবে

— TwiNight
সূত্র

আমার বোধগম্যতা হল আপনার প্রোগ্রামটি যদি ASCII এর পরিবর্তে ইউনিকোড বিস্তৃত এমন অক্ষর ব্যবহার করে লেখা হয় তবে বাইট গণনাটিতে ইউনিকোডের প্রতি-বাইট-বাইট-স্বীকৃতি স্বীকৃতি দেওয়া দরকার।

— সিটিও

@COTO আমি ইউনিকোড নির্দিষ্ট করে নি। যতদূর আমি সচেতন আছি, APL অক্ষর সেট একটি বাইট মধ্যে মাপসই করা হবে না, এবং হয় একক বাইট কোড পৃষ্ঠাগুলি যা সব APL অক্ষর যাতে এনকোডিং ব্যবহার করে,, বাইট গণনা জরিমানা। বাইট দ্বারা গণনা বেশিরভাগই সেই লোকদের জন্য প্রাসঙ্গিক যারা "নরমাল" ভাষায় মাল্টি-বাইট স্ট্রিংগুলিতে স্টকগুলি এনকোড করছেন বা যারা ম্যাথমেটিকার ইউনিকোড শর্টকাট ব্যবহার করেন।

— মার্টিন এন্ডার

@ মার্টিনবাটনার: সুতরাং আপনি বলছেন যে কেউ এপিএলের জন্য স্পষ্টভাবে ডিজাইন করা ছাড়াও কোনও পাঠ্য সম্পাদকের ক্ষেত্রে স্ট্রিংয়ের 1-বাইট-প্রতি-চরিতাকে যুক্তিসঙ্গতভাবে বা ব্যবহারিকভাবে উপস্থাপন করতে পারেন নি, এটি প্রতি বাইট-প্রতি-বাইট হিসাবে গণনা করা হয় কারণ ভাষা অনুচ্ছেদে 256 বা তার চেয়ে কম অনুমোদিত অক্ষর রয়েছে?

— COTO

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

— মার্টিন ইন্ডার

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

— মার্টিন এন্ডার

জাভাস্ক্রিপ্ট - 393 বাইট

minified:

F=(s,a,t,b,e,x)=>(x=e||F(t,b,s,a,1),[A,B]=a,[C,D]=b,r=(p,l)=>([g,h]=l,[f,i]=y(h,g),[j,k]=y(p,g),m=Math.sqrt(f*f+i*i),[(f*j+i*k)/m,(f*k-i*j)/m]),u=(p,c)=>([f,g]=c,[i,j]=y(p,f),i*i+j*j<g*g),y=(p,c)=>[p[0]-c[0],p[1]-c[1]],[n,o]=r(C,a),[q,v]=r(D,a),w=(v*n-o*q)/(v-o),z=r(B,a)[0],Y=u(A,b),Z=u(B,b),[v*o<0&&w*(w-z)<0,Y||Z||o<D&&o>-D&&n*(n-z)<0,!Y||!Z,x,u(A,[C,D+B]),B>D||!u(A,[C,D-B]),x,x,1][s*3+t])

সম্প্রসারিত:

F = (s,a,t,b,e,x) => (
    x = e || F(t,b,s,a,1),
    [A,B] = a,
    [C,D] = b,
    r = (p,l) => (
        [g,h] = l,
        [f,i] = y(h,g),
        [j,k] = y(p,g),
        m = Math.sqrt( f*f + i*i ),
        [(f*j + i*k)/m, (f*k - i*j)/m] ),
    u = (p,c) => (
        [f,g] = c,
        [i,j] = y(p,f),
        i*i + j*j < g*g ),
    y = (p,c) => [p[0] - c[0], p[1] - c[1]],
    [n,o] = r(C,a),
    [q,v] = r(D,a),
    w = (v*n - o*q)/(v - o),
    z = r(B,a)[0],
    Y = u(A,b), Z = u(B,b),
    [   v*o < 0 && w*(w-z) < 0,
        Y || Z || o < D && o > -D && n*(n-z) < 0,
        !Y || !Z,
        x,
        u(A,[C,D+B]),
        B > D || !u(A,[C,D-B]),
        x,
        x,
        1
    ][s*3+t]);

নোট:

Fপ্রয়োজনীয় আর্গুমেন্ট গ্রহণ করে এবং প্রয়োজনীয় মানটি প্রদান করে এমন ফাংশনটি সংজ্ঞায়িত করে
ইনপুট ফর্ম্যাটটি ওপিতে ফর্ম্যাট করার অনুরূপ, প্রতিটি আদিমের জন্য পূর্ণসংখ্যার টাইপ কোডটি টিপল থেকে পৃথক। উদাহরণস্বরূপ, F( 0,[[0,0],[2,2]], 0,[[1,0],[2,4]] )বা F( 1,[[3,0],1], 2,[[0,0],1] )।
ওপিতে সরবরাহিত সমস্ত পরীক্ষার ক্ষেত্রে কোড বৈধতাযুক্ত
শূন্য-দৈর্ঘ্যের রেখাংশগুলি এবং শূন্য-ব্যাসার্ধ বৃত্ত সহ সমস্ত প্রান্ত এবং কোণার কেসগুলি পরিচালনা করা উচিত

— Coto
সূত্র

আহ, এই দুটি ধারার কেস উল্লেখ করার জন্য ধন্যবাদ। শূন্য-ব্যাসার্ধের বৃত্তগুলি পরিচালনা করতে হবে না (পোস্টটি ইতিবাচক ব্যাসার্ধ বলেছে), এবং আমি আরও স্পষ্ট করে বলতে পারি যে লাইন বিভাগের প্রান্তটি পৃথক হবে।

— মার্টিন ইন্ডার

পাইথন, 284

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

Golfed:

import math,random as r
n=lambda(a,c),(b,d):math.sqrt((a-b)**2+(c-d)**2)
x=lambda(t,a,b),p:max(eval(["n(b,p)-n(a,b)+","-b+","b-"][t]+'n(a,p)'),0)
def F(t,j):
q=0,0;w=1e9
 for i in q*9000:
    y=x(t,q)+x(j,q)
    if y<w:p,w=q,y
    q=(r.random()-.5)*w+p[0],(r.random()-.5)*w+p[1]
 return w<.0001

Ungolfed:

import math
import random as r
def norm(a, b):
 return math.sqrt((a[0] - b[0])**2 + (a[1] - b[1])**2)

def lineWeight(a, b, p):
 l1 = norm(a, p)
 l2 = norm(b, p)
 return min(l1, l2, l1 + l2 - norm(a, b))

def circleWeight(a, r, p):
 return max(0, norm(a, p) - r)

def voidWeight(a, r, p):
 return max(0, r - norm(a, p))

def weight(f1, f2, s1, s2, p):
 return f1(s1[1], s1[2], p) + f2(s2[1], s2[2], p)

def checkCollision(s1, s2):
 a = [lineWeight, circleWeight, voidWeight]
 f1 = a[s1[0]]
 f2 = a[s2[0]]
 p = (0.0, 0.0)
 w = 0
 for i in a*1000:
  w = weight(f1, f2, s1, s2, p)
  p2 = ((r.random()-.5)*w + p[0], (r.random()-.5)*w + p[1])
  if(weight(f1, f2, s1, s2, p2) < w):
   p = p2
 if w < .0001:
  return True
 return False

এবং পরিশেষে, অন্য কেউ অজগরে এটি চেষ্টা করতে চাইলে একটি পরীক্ষা স্ক্রিপ্ট:

import collisiongolfedbak
reload(collisiongolfedbak)

tests = [
[0,[0,0],[2,2]], [0,[1,0],[2,4]],        # Crossing line segments
[0,[0.5,0],[-0.5,0]], [1,[0,0],1],       # Line contained in a disc
[0,[0.5,0],[1.5,0]], [1,[0,0],1],        # Line partially within disc
[0,[-1.5,0.5],[1.5,0.5]], [1,[0,0],1],   # Line cutting through disc
[0,[0.5,2],[-0.5,2]], [2,[0,0],1],       # Line outside cavity
[0,[0.5,0],[1.5,0]], [2,[0,0],1],        # Line partially outside cavity
[0,[-1.5,0.5],[1.5,0.5]], [2,[0,0],1],   # Line cutting through cavity
[1,[0,0],1], [1,[0,0],2],                # Disc contained within another
[1,[0,0],1.1], [1,[2,0],1.1],            # Intersecting discs
[1,[3,0],1], [2,[0,0],1],                # Disc outside cavity
[1,[1,0],0.1], [2,[0,0],1],              # Disc partially outside cavity
[1,[0,0],2], [2,[0,0],1],                # Disc encircling cavity
[2,[0,0],1], [2,[0,0],1] ,               # Any two cavities intersect
[2,[-1,0],1], [2,[1,0],1] ,              # Any two cavities intersect
[0,[0,0],[1,0]], [0,[0,1],[1,1]] ,       # Parallel lines
[0,[-2,0],[-1,0]], [0,[1,0],[2,0]],      # Collinear non-overlapping lines
[0,[0,0],[2,0]], [0,[1,1],[1,2]],        # Intersection outside one segment
[0,[0,0],[1,0]], [0,[2,1],[2,3]],        # Intersection outside both segments
[0,[-1,2],[1,2]], [1,[0,0],1],           # Line passes outside disc
[0,[2,0],[3,0]], [1,[0,0],1],            # Circle lies outside segment
[0,[-0.5,0.5],[0.5,-0.5]], [2,[0,0],1],  # Line inside cavity
[1,[-1,0],1], [1,[1,1],0.5],             # Non-intersecting circles
[1,[0.5,0],0.1], [2,[0,0],1]            # Circle contained within cavity
]

for a, b in zip(tests[0::2], tests[1::2]):
 print collisiongolfedbak.F(a,b)

— QuadmasterXLII
সূত্র