3 ডি স্পেসে রৈখিক দূরত্ব দ্বারা পয়েন্টগুলি বাছাই করুন

15

চশমা

  1. আপনার x,y,zআকারের কিউবিক 3D স্থান রয়েছেS পূর্ণসংখ্যার এককগুলির মতো0 <= x,y,z <= S ।
  2. আপনি ডিফল্ট ইনপুট পদ্ধতিগুলিP হিসাবে উপস্থাপিত পয়েন্টগুলির একটি অ্যারে পাবেনx,y,z , কোন যুক্তিসঙ্গত বিন্যাসে পূর্ণসংখ্যা স্থানাঙ্ক আপনি যতবার চাইবেন উদাহরণস্বরূপ: [x1,y1,z1],[x2,y2,z2],[x3,y3,z3] ... [xn,yn,zn]।
  3. সব P মানগুলি উপরে বর্ণিত ঘনক 3 ডি স্পেসে থাকবে 0 <= x,y,z <= S।
  4. সম্ভাব্য মোট সংখ্যা P হবে ।1 <= P <= S3
  5. আপনি বেস পয়েন্ট এবং 3 ডি কিউব আকারের x,y,zপূর্ণসংখ্যা স্থানাঙ্ক হিসাবে ইনপুট হিসাবে পাবেন BS ।

কার্য

আপনার লক্ষ্য আউটপুট হয়, আপনার পছন্দের ফরম্যাটে, পয়েন্ট Pরৈখিক অনুসারে সাজানো (ইউক্লিডিয়) থেকে দূরত্ব বেস বিন্দু B ।

বিধি

  1. যদি আপনি একাধিক পয়েন্ট খুঁজে Pপান যা Bআপনার থেকে সামঞ্জস্যপূর্ণ হয় তবে অবশ্যই Pআপনার পছন্দসই ক্রমে সমস্ত সামঞ্জস্যপূর্ণ এর আউটপুট দিতে হবে ।
  2. এটি সম্ভব যে কোনও পয়েন্টের Pসাথে মিলে যায় B, যাতে তাদের দূরত্ব হয় 0, আপনাকে অবশ্যই সেই বিন্দুটিকে আউটপুট করতে হবে।
  3. এটি একটি কোড-গল্ফ চ্যালেঞ্জ, তাই সংক্ষিপ্ততম কোডটি জয়ী।
  4. স্ট্যান্ডার্ড লুফোলগুলি নিষিদ্ধ।
  5. কোড ব্যাখ্যা প্রশংসা করা হয়।

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

Input:
S (size), [B (base point x,y,z)], [P1 (x,y,z)], [P2], [P3], [P4], [P5], [...], [Pn]
10, [5,5,5], [0,0,0], [10,10,10], [2,0,8], [10,3,1], [4,4,5], [5,5,5], [5,5,4]

Output:
[5,5,5], [5,5,4], [4,4,5], [2,0,8], [10,3,1], [0,0,0], [10,10,10]

- - -

Input:
5, [2, 3, 3], [3, 0, 4], [5, 0, 3], [0, 2, 4], [0, 3, 5], [4, 2, 1], [2, 2, 2], [3, 1, 2], [3, 1, 0], [1, 3, 2], [2, 3, 1], [3, 1, 5], [4, 0, 0], [4, 3, 1], [0, 5, 5], [1, 5, 1], [3, 1, 4], [2, 2, 2], [0, 2, 5], [3, 3, 5], [3, 3, 0], [5, 4, 5], [4, 1, 3], [5, 1, 1], [3, 5, 3], [1, 5, 3], [0, 5, 2], [4, 3, 3], [2, 1, 1], [3, 3, 0], [5, 0, 4], [1, 5, 2], [4, 2, 3], [4, 2, 1], [2, 5, 5], [3, 4, 0], [3, 0, 2], [2, 3, 2], [3, 5, 1], [5, 1, 0], [2, 4, 3], [1, 0, 5], [0, 2, 5], [3, 4, 4], [2, 4, 0], [0, 1, 5], [0, 5, 4], [1, 5, 1], [2, 1, 0], [1, 3, 4], [2, 2, 2], [4, 2, 4], [5, 5, 4], [4, 4, 0], [0, 4, 1], [2, 0, 3], [3, 1, 5], [4, 4, 0], [2, 5, 1], [1, 2, 4], [4, 3, 1], [0, 2, 4], [4, 5, 2], [2, 0, 1], [0, 0, 2], [4, 1, 0], [5, 4, 3], [2, 5, 2], [5, 4, 4], [4, 4, 3], [5, 5, 1], [4, 0, 2], [1, 3, 5], [4, 2, 0], [0, 3, 1], [2, 2, 0], [0, 4, 5], [3, 2, 0], [0, 2, 1], [1, 2, 2], [2, 5, 3], [5, 5, 2], [5, 2, 4], [4, 5, 5], [2, 1, 2], [5, 4, 3], [4, 5, 4], [2, 3, 1], [4, 4, 4], [3, 0, 0], [2, 4, 5], [4, 3, 3], [3, 5, 3], [4, 0, 0], [1, 1, 1], [3, 1, 3], [2, 5, 5], [0, 0, 5], [2, 0, 2], [1, 0, 3], [3, 1, 4], [1, 2, 5], [4, 1, 3], [1, 4, 5], [3, 1, 4], [3, 5, 1], [5, 1, 4], [1, 0, 4], [2, 2, 0], [5, 2, 1], [0, 5, 3], [2, 1, 1], [0, 3, 0], [4, 5, 5], [3, 4, 2], [5, 3, 3], [3, 1, 1], [4, 0, 1], [5, 0, 5], [5, 0, 4], [1, 4, 3], [5, 4, 2], [5, 4, 0], [5, 1, 0], [0, 0, 1], [5, 3, 0]

Output:
[2, 4, 3], [2, 3, 2], [1, 3, 4], [1, 3, 2], [2, 2, 2], [1, 4, 3], [2, 2, 2], [2, 2, 2], [1, 2, 2], [3, 4, 2], [1, 2, 4], [3, 4, 4], [2, 5, 3], [4, 3, 3], [2, 3, 1], [4, 3, 3], [2, 3, 1], [1, 3, 5], [4, 4, 3], [2, 5, 2], [3, 1, 3], [1, 5, 3], [4, 2, 3], [2, 1, 2], [3, 5, 3], [2, 4, 5], [3, 3, 5], [3, 5, 3], [3, 1, 4], [0, 2, 4], [0, 2, 4], [1, 2, 5], [3, 1, 2], [3, 1, 4], [3, 1, 4], [4, 2, 4], [1, 4, 5], [4, 4, 4], [1, 5, 2], [4, 3, 1], [0, 5, 3], [2, 1, 1], [4, 1, 3], [4, 3, 1], [2, 5, 5], [0, 3, 5], [4, 1, 3], [2, 5, 1], [2, 1, 1], [0, 3, 1], [2, 5, 5], [1, 1, 1], [0, 4, 5], [4, 5, 4], [4, 5, 2], [0, 2, 1], [1, 5, 1], [5, 3, 3], [0, 5, 2], [3, 5, 1], [3, 5, 1], [0, 2, 5], [1, 5, 1], [4, 2, 1], [3, 1, 5], [3, 1, 1], [0, 2, 5], [4, 2, 1], [0, 5, 4], [0, 4, 1], [2, 0, 3], [3, 1, 5], [2, 4, 0], [2, 2, 0], [2, 0, 2], [3, 3, 0], [3, 3, 0], [5, 4, 3], [1, 0, 3], [5, 4, 3], [2, 2, 0], [3, 0, 2], [5, 4, 4], [5, 4, 2], [1, 0, 4], [3, 0, 4], [5, 2, 4], [3, 2, 0], [3, 4, 0], [0, 1, 5], [0, 5, 5], [4, 5, 5], [4, 5, 5], [0, 3, 0], [2, 0, 1], [2, 1, 0], [4, 4, 0], [5, 1, 4], [5, 5, 4], [5, 2, 1], [3, 1, 0], [5, 4, 5], [4, 4, 0], [1, 0, 5], [4, 2, 0], [0, 0, 2], [4, 0, 2], [5, 5, 2], [4, 1, 0], [5, 5, 1], [0, 0, 1], [5, 1, 1], [4, 0, 1], [0, 0, 5], [5, 0, 3], [5, 3, 0], [5, 4, 0], [3, 0, 0], [5, 0, 4], [5, 0, 4], [5, 1, 0], [4, 0, 0], [4, 0, 0], [5, 0, 5], [5, 1, 0]

- - -

Input:
10, [1, 9, 4], [4, 6, 2], [7, 5, 3], [10, 5, 2], [9, 8, 9], [10, 5, 10], [1, 5, 4], [8, 1, 1], [8, 6, 9], [10, 4, 1], [3, 4, 10], [4, 7, 0], [7, 10, 9], [5, 7, 3], [6, 7, 9], [5, 1, 4], [4, 3, 8], [4, 4, 9], [6, 9, 3], [8, 2, 6], [3, 5, 1], [0, 9, 0], [8, 4, 3], [0, 1, 1], [6, 7, 6], [4, 6, 10], [3, 9, 10], [8, 3, 1], [10, 1, 1], [9, 10, 6], [2, 3, 9], [10, 5, 0], [3, 2, 1], [10, 2, 7], [8, 4, 9], [5, 2, 4], [0, 8, 9], [10, 1, 6], [0, 8, 10], [5, 10, 1], [7, 4, 5], [4, 5, 2], [0, 2, 0], [8, 3, 3], [6, 6, 6], [3, 0, 2], [0, 1, 1], [10, 10, 8], [6, 2, 8], [8, 8, 6], [5, 4, 7], [10, 7, 4], [0, 9, 2], [1, 6, 6], [8, 5, 9], [3, 7, 4], [5, 6, 6], [3, 1, 1], [10, 4, 5], [1, 5, 7], [8, 6, 6], [4, 3, 7], [2, 1, 0], [6, 4, 2], [0, 7, 8], [8, 3, 6], [9, 2, 0], [1, 3, 8], [4, 4, 6], [5, 8, 9], [9, 4, 4], [0, 7, 3], [8, 3, 4], [6, 7, 9], [8, 7, 0], [0, 7, 7], [8, 10, 10], [10, 2, 5], [6, 9, 5], [6, 2, 7], [0, 9, 6], [1, 4, 1], [4, 3, 1], [5, 7, 3], [9, 6, 8], [4, 1, 7], [4, 0, 8], [3, 4, 7], [2, 3, 6], [0, 0, 7], [5, 3, 6], [7, 3, 4], [6, 7, 8], [3, 7, 9], [1, 9, 10], [2, 1, 2], [2, 8, 2], [0, 3, 0], [1, 1, 9], [3, 5, 2], [10, 5, 3], [5, 2, 9], [6, 9, 0], [9, 5, 0], [7, 1, 10], [3, 3, 8], [2, 5, 1], [3, 10, 10], [6, 2, 2], [10, 7, 2], [4, 3, 1], [4, 2, 1], [4, 2, 8], [6, 8, 5], [3, 10, 0], [1, 1, 7], [6, 9, 6], [6, 2, 4], [5, 5, 7], [5, 4, 5], [9, 8, 1], [9, 8, 1], [0, 10, 6], [1, 1, 9], [3, 8, 8], [3, 1, 5], [5, 7, 4], [4, 3, 6], [5, 4, 7], [6, 0, 8], [7, 8, 1], [9, 8, 4], [2, 10, 0], [3, 4, 5], [9, 3, 10], [7, 4, 1], [2, 1, 9], [10, 8, 1], [10, 3, 7], [2, 0, 6], [3, 8, 4], [10, 0, 2], [9, 9, 10], [8, 9, 5], [4, 10, 2], [8, 3, 4], [4, 2, 10], [9, 1, 6], [6, 1, 3], [4, 1, 3], [2, 9, 0], [5, 6, 5], [8, 8, 3], [5, 5, 0], [7, 6, 9], [1, 1, 5], [3, 0, 4], [1, 10, 6], [8, 0, 2], [0, 7, 3], [8, 9, 8], [2, 1, 8], [3, 1, 10], [4, 5, 9], [7, 6, 10], [3, 6, 10], [5, 9, 8], [9, 3, 3], [2, 2, 3], [9, 9, 0], [7, 2, 2], [0, 0, 9], [8, 7, 4], [9, 2, 9], [0, 6, 4], [9, 4, 3], [10, 1, 3], [5, 9, 10], [5, 10, 6], [6, 3, 10], 

Output: 
[1, 10, 6], [3, 8, 4], [0, 9, 6], [0, 9, 2], [2, 8, 2], [0, 7, 3], [0, 7, 3], [0, 10, 6], [3, 7, 4], [0, 6, 4], [1, 6, 6], [0, 7, 7], [4, 10, 2], [1, 5, 4], [0, 9, 0], [2, 9, 0], [2, 10, 0], [5, 7, 4], [5, 7, 3], [5, 10, 6], [5, 7, 3], [0, 7, 8], [3, 10, 0], [3, 8, 8], [4, 6, 2], [3, 5, 2], [1, 5, 7], [5, 10, 1], [6, 9, 3], [6, 9, 5], [5, 6, 5], [2, 5, 1], [0, 8, 9], [6, 8, 5], [5, 6, 6], [6, 9, 6], [4, 5, 2], [4, 7, 0], [3, 5, 1], [3, 4, 5], [5, 9, 8], [6, 7, 6], [3, 7, 9], [1, 4, 1], [1, 9, 10], [4, 4, 6], [0, 8, 10], [6, 6, 6], [3, 4, 7], [3, 9, 10], [5, 5, 7], [3, 10, 10], [2, 3, 6], [6, 9, 0], [5, 8, 9], [5, 4, 5], [6, 7, 8], [7, 8, 1], [5, 5, 0], [4, 3, 6], [3, 6, 10], [8, 9, 5], [5, 4, 7], [4, 5, 9], [5, 4, 7], [2, 2, 3], [8, 8, 3], [1, 3, 8], [5, 9, 10], [0, 3, 0], [7, 5, 3], [8, 7, 4], [4, 3, 1], [8, 8, 6], [6, 4, 2], [4, 3, 7], [6, 7, 9], [4, 6, 10], [4, 3, 1], [6, 7, 9], [3, 3, 8], [5, 3, 6], [4, 4, 9], [4, 3, 8], [8, 6, 6], [3, 2, 1], [7, 4, 5], [7, 10, 9], [2, 3, 9], [5, 2, 4], [1, 1, 5], [3, 4, 10], [8, 9, 8], [9, 8, 4], [0, 2, 0], [4, 2, 1], [3, 1, 5], [2, 1, 2], [8, 7, 0], [9, 10, 6], [7, 4, 1], [7, 6, 9], [7, 3, 4], [1, 1, 7], [0, 1, 1], [4, 2, 8], [9, 8, 1], [0, 1, 1], [4, 1, 3], [6, 2, 4], [9, 8, 1], [8, 4, 3], [3, 1, 1], [6, 2, 2], [5, 1, 4], [9, 9, 0], [7, 6, 10], [2, 1, 0], [2, 1, 8], [4, 1, 7], [8, 6, 9], [6, 2, 7], [8, 3, 4], [8, 3, 4], [10, 7, 4], [3, 0, 4], [8, 3, 3], [8, 10, 10], [2, 0, 6], [9, 6, 8], [10, 7, 2], [1, 1, 9], [8, 3, 6], [1, 1, 9], [7, 2, 2], [3, 0, 2], [9, 4, 4], [8, 5, 9], [2, 1, 9], [6, 1, 3], [6, 2, 8], [5, 2, 9], [9, 4, 3], [9, 8, 9], [0, 0, 7], [10, 8, 1], [4, 2, 10], [8, 3, 1], [9, 5, 0], [6, 3, 10], [10, 10, 8], [10, 5, 3], [8, 4, 9], [9, 9, 10], [10, 5, 2], [9, 3, 3], [8, 2, 6], [3, 1, 10], [4, 0, 8], [0, 0, 9], [10, 4, 5], [10, 5, 0], [10, 4, 1], [8, 1, 1], [6, 0, 8], [10, 3, 7], [9, 2, 0], [10, 2, 5], [9, 1, 6], [10, 5, 10], [8, 0, 2], [9, 3, 10], [7, 1, 10], [9, 2, 9], [10, 2, 7], [10, 1, 3], [10, 1, 6], [10, 1, 1], [10, 0, 2]

- - -

Input:
10000, [8452, 3160, 6109], [7172, 5052, 4795], [9789, 4033, 2952], [8242, 213, 3835], [177, 7083, 908], [3788, 3129, 3018], [9060, 464, 2701], [6537, 8698, 291], [9048, 3860, 6099], [4600, 2696, 4854], [2319, 3278, 9825]

Output:
[9048, 3860, 6099], [7172, 5052, 4795], [9789, 4033, 2952], [8242, 213, 3835], [4600, 2696, 4854], [9060, 464, 2701], [3788, 3129, 3018], [2319, 3278, 9825], [6537, 8698, 291], [177, 7083, 908]
code-golf  geometry  integer 
— মারিও
সূত্র
1
Sপ্যারামিটার হিসাবে গ্রহণ করা কি সত্যই প্রয়োজন ?
— ক্রিশ্চিয়ান লুপাস্কু
@ গল্ফ ওল্ফ যদি আপনার এটির প্রয়োজন না হয় তবে তা নেবেন না।
— মারিও
2
আপনি আমাদের কোন ধরণের মেট্রিক ব্যবহার করতে চান তা উল্লেখ করার জন্য আমি দৃ strongly়তার সাথে সুপারিশ করব। কিছু লোক ইউক্লিডিয়ান মেট্রিক ব্যবহার করে (ρ = √ [(x₁-x₂) ² + (y₁-y₂) ² + (z₁-z₂) ²])), অন্যরা ম্যানহাটন মেট্রিক ব্যবহার করে (ρ = | x₁-x₂ | + | y₁-y₂ | + | z₁-z₂ |)। আমার মতে প্রত্যেকের একই মেট্রিক ব্যবহার করা উচিত।
— Ramillies
4
@Ramillies: চ্যালেঞ্জ নির্দিষ্ট করে দূরত্ব রৈখিক যা আমার মনে হয় ইউক্লিডিয় । আমি ম্যানহাটানকে লিনিয়ার বলব না , তবে আমি সম্মত হই যে নির্দিষ্টভাবে কোন মেট্রিকটি ব্যবহার করা উচিত তা নির্দিষ্ট করে চ্যালেঞ্জকে ভুল বোঝার পক্ষে আরও কঠিন করা উচিত।
— Emigna
1
রৈখিক বলবেন না, ইউক্লিডিয়ান বলুন।
— লিন্ডন হোয়াইট

উত্তর:

11

05 এ বি 1 ই , 4 বাইট

ΣαnO

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

Σ        # sort by
   O     # sum of
  n      # square of
 α       # absolute difference between current value and second input
— Emigna
সূত্র
তোমার দরকার কেন n?
— এরিক আউটগলফার
@ এরিকথ আউটগলফার: সম্ভবত এই ছোট উদাহরণটি স্কোয়ারিংয়ের মধ্যে পার্থক্য দেখাতে পারে এবং নাও।
— Emigna
তো, সবাই কি এটি ভুল করছে বা প্রত্যেকেই এটি সঠিকভাবে করছে?
— এরিক আউটগল্ফার
@ এরিকথ আউটগলফার: আমি সমস্ত উত্তর চেক করিনি, তবে বেশিরভাগই সঠিক বলে মনে হচ্ছে।
— এমিগানা
অনেক উত্তর বর্গক্ষেত্র হয় না, এজন্যই আমি জিজ্ঞাসা করেছি, যেহেতু তারা ঠিক একই অ্যালগরিদম ব্যবহার করছে।
— এরিক আউটগলফার
6

জাভাস্ক্রিপ্ট (ES6), 71 বাইট

(b,a,g=a=>a.reduce((d,c,i)=>d+(c-=b[i])*c,0))=>a.sort((b,a)=>g(b)-g(a))
— নিল
সূত্র
আমার মনে হয় আপনি gভিতরে কারিরিং এবং মুভিং সংজ্ঞা ব্যবহার করে একটি বাইট সংরক্ষণ করতে পারেন sort।
1
@ দ্য পাইরেটবে: নীল কারি করায় না!
— শেগি
6

হাস্কেল , 54 52 বাইট

import Data.List
f o=sortOn(sum.map(^2).zipWith(-)o)

এটি অনলাইন চেষ্টা করুন!

আমার জায়গার আকার দরকার নেই। sum.map(^2).zipWith(-)oকরার জন্য একটি বিন্দু থেকে দুরত্ব গণনা o: (xo-xp)^2+(yo-yp)^2+(zo-zp)^2। পয়েন্টগুলি কেবল দূরত্বে সাজানো হয়o ।

সম্পাদনা করুন : "আপনার যদি এটির প্রয়োজন না হয় তবে এটি নেবেন না" সংরক্ষণ করা 2 বাইট।

— jferard
সূত্র
4

আর , 56 40 বাইট

-16 বাইটগুলি আলাদা ইনপুট ফর্ম্যাটটির জন্য ফ্লোডেলকে ধন্যবাদ জানায়

function(P,B)P[,order(colSums((P-B)^2))]

এটি অনলাইন চেষ্টা করুন!

পয়েন্টগুলির ম্যাট্রিক্স Pহিসাবে গ্রহণ করে 3xn, অর্থাৎ প্রতিটি কলাম একটি বিন্দু; আউটপুট একই বিন্যাসে।

পরীক্ষার কেসগুলি থেকে gপয়েন্টগুলির তালিকাটিকে Pযথাযথ আর ফর্ম্যাটে রূপান্তর করতে সহায়ক ফাংশনটি ব্যবহার করুন ।

— : Giuseppe
সূত্র
1
সম্ভবত এর sapply()সাথে প্রতিস্থাপন করুন colSums((t(P)-B)^2), যেখানে ইনপুটটি Pম্যাট্রিক্স হবে?
— ফ্লোডেল
@ ফ্লোডেল যদি আমি এটি করতে যাচ্ছি তবে আমি Pএকটি 3xnম্যাট্রিক্স হিসাবে গ্রহণ করতে পারি এবং colSums((P-B)^2)পরিবর্তে এটি করতে পারি !
— জিউসেপ
3

গণিত, 24 বাইট

xN@Norm[#-x]&//SortBy

ফর্ম্যাটে ইনপুট নেয় f[B][P]।

xনেস্টেড ফাংশনটি তৈরি করতে আমাদের 4 টি বাইট ব্যবহার করতে হবে।  ( \[Function]) এর অগ্রাধিকার এবং //সুন্দরভাবে কাজ করে যাতে ভাবটি এর সমান হয়:

Function[x, SortBy[N@Norm[# - x]&] ]

আমাদের প্রয়োজন Nকারণ ডিফল্টরূপে, গাণিতিক মান অনুসারে পরিবর্তিত অভিব্যক্তি কাঠামোর দ্বারা সাজান:

Sort[{1, Sqrt@2, 2}]
{1, 2, Sqrt[2]}

SortBy[N][{1, Sqrt@2, 2}]
{1, Sqrt[2], 2}
— hftf
সূত্র
3

সি # (.নেট কোর) , 68 57 53 + 23 18 বাইট

-11 বাইট ধন্যবাদ এমিগিনার কাছে

B=>P=>P.OrderBy(p=>p.Zip(B,(x,y)=>(x-y)*(x-y)).Sum())

বাইট গণনা অন্তর্ভুক্ত

using System.Linq;

এটি অনলাইন চেষ্টা করুন!

পয়েন্টগুলি ইন্টের সংগ্রহ হিসাবে বিবেচিত হয়। ব্যাখ্যা:

B => P =>                          // Take the base point and a collection of points to sort
    P.OrderBy(p =>                 // Order the points by:
        p.Zip(B, (x, y) =>         //     Take each point and combine it with the base:
            (x - y) * (x - y)      //         Take each dimension and measure their distance squared
        ).Sum()                    //     Sum of the distances in each dimension together
    )
— গ্রেজগোর্জ পুয়াওস্কি
সূত্র
3

জাভাস্ক্রিপ্ট (ES6), 72 71 বাইট

এটি নীলের উত্তরের চেয়ে সংক্ষিপ্ত নয় , তবে আমি ভেবেছিলাম যে Math.hypot()ES6-এ প্রবর্তিত, এর ব্যবহারটি প্রদর্শন করতে আমি যেভাবেই পোস্ট করব ।

বাক্য গঠন বাক্য গঠনে ইনপুট নেয় (p)(a), যেখানে p = [x, y, z] হল মূল বিন্দু এবং a হল অন্যান্য পয়েন্টগুলির অ্যারে ray

p=>a=>a.sort((a,b)=>(g=a=>Math.hypot(...a.map((v,i)=>v-p[i])))(a)-g(b))

কোড স্নিপেট দেখান

— আরনাউল্ড
সূত্র
3

k , 14 বাইট

{y@<+/x*x-:+y}

এটি অনলাইন চেষ্টা করুন!

{            } /function(x,y)
           +y  /transpose y
        x-:    /w[j,i] = x[j] - y[j,i]
      x*       /w[j,i]*w[j,i]
    +/         /v[i] = sum over all j: w[j,i]
   <           /indices to sort by
 y@            /rearrange list of points by indices

এছাড়াও, এটি n মাত্রার জন্য কাজ করে এবং এটি 3 এর মধ্যে সীমাবদ্ধ নয়।

— zgrep
সূত্র
3

জাপট , 10 9 বাইট

-1 বাইট @ শ্যাগিকে ধন্যবাদ thanks

ñ_íaV m²x

এই ক্রমে তিন-আইটেম অ্যারে এবং বেস পয়েন্টটিকে একটি একক অ্যারে হিসাবে পয়েন্ট নেয়। আকারের যুক্তি গ্রহণ করে না।

এটি অনলাইন চেষ্টা করুন! বা এর সাথে বিশাল পরীক্ষার মামলাটি চালান-R আউটপুট একx,y,z লাইন প্রতি ।

ব্যাখ্যা

ñ_            Sort the input array as if each item were mapped through the function...
  í V         Pair the x,y,z in the current item with those in the base point, V
   a          Take the absolute different from each pair
      m²      Square each of the 3 differences
        x     Sum those squares
              Sorted array is implicitly returned
— জাস্টিন মেরিনার
সূত্র
ভাল লাগল :) কাজের পথে নামার আগে আমি 11 বাইটে নামলাম !
— শেগি
দেখে মনে হচ্ছে এই 9 বাইট জন্য কাজ করা উচিত, কিন্তু এটা আরো কিছু পরীক্ষামূলক প্রয়োজন। সম্পাদনা: উভয় সংস্করণ দ্বিতীয় এবং তৃতীয় পরীক্ষার ক্ষেত্রে ব্যর্থ fail
— শেগি
@ শেগি আমি কখনই বুঝতে পারি নি যে íএটির যুক্তিগুলি বিপরীতে গ্রহণ করতে পারে, এটি দুর্দান্ত। আমিও মনে করি এটি কাজ করা উচিত; আমি অন্য কয়েকটি পরীক্ষার মামলা চালাব এবং কম্পিউটারে ফিরে এলে সম্পাদনা করব।
— জাস্টিন মেরিনার
দ্রষ্টব্য: -বা nএর জায়গায়ও কাজ করবে a।
— শেগি
2

এমএটিএল , 7 বাইট

yZP&SY)

ইনপুটগুলি হ'ল: সারি হিসাবে পয়েন্ট সহ 3-কলাম ম্যাট্রিক্স এবং বেস পয়েন্ট সহ 3-কলামের ভেক্টর।

এমএটিএল অনলাইনে এটি ব্যবহার করে দেখুন !

ব্যাখ্যা

y   % Implicitly take two inputs: 3-column matrix and 3-row vector. Duplicate the first
    % STACK: input 1 (matrix), input 2 (vector), input 1 (matrix)
ZP  % Euclidean distance between rows of top two elements in stack
    % STACK: input 1 (matrix), distances (vector)
&S  % Sort and push the indices of the sorting (not the sorted values)
    % STACK: input 1 (matrix), indices (vector)
Y)  % Use as row indices. Implicitly display
    % STACK: final result (matrix)
— লুইস মেন্ডো
সূত্র
2

জেলি , 5 বাইট

1 বাইট সংরক্ষণ করা হয়েছে, লিকি নুনকে ধন্যবাদ ।

ạ²SðÞ

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

ạ²SðÞ

    Þ - কী ফাংশন অনুসারে বাছাই করুন।
ạ - দ্বিতীয় ইনপুট তালিকার উপাদানগুলির সাথে সম্পূর্ণ পার্থক্য।
 ² - স্কয়ার Vectorizes।
  এস - সম
   ð - একটি পৃথক ডায়াডিক চেইন শুরু করে।
      - স্পষ্টভাবে আউটপুট।
— মিঃ এক্সকোডার
সূত্র
একটি বাইট সংরক্ষণ করুন ạS¥Þ(আমার পোস্টের আগে আপনার উত্তর লক্ষ্য করেনি)।
— এরিক আউটগল্ফার
হুম ... আমি মনে করি আপনাকে 5 বাইটে ফিরে যেতে হবে যেহেতু আমি পেয়েছি যে আপনাকে বর্গাকার করতে হবে :ạ²SµÞ
— এরিক দি আউটগলফার
@ এরিকথ আউটগল্ফার আমার ধারণা আমি এখনই এটি ঠিক করেছি। যদিও নিশ্চিত নয়
— মিঃ এক্সকোডার
আপনার যোগফল (ভেক্টরাইজ) করার আগে স্কোয়ার করা দরকার, পরে নয়।
— এরিক আউটগল্ফার
@EriktheOutgolfer এখন ঠিক হওয়া উচিত
— জনাব Xcoder
2

পার্ল 6 , 35 বাইট (33 অক্ষর)

{@^b;@^p.sort:{[+] ($_ Z- @b)»²}}

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা: এটি বেস পয়েন্ট (ডাকা @b) এর স্থানাঙ্কের সাথে একটি তালিকা নেয় , তারপরে অন্যান্য পয়েন্টগুলির স্থানাঙ্কের সাথে তালিকার একটি তালিকা (ডাকা @p)। একটি ব্লকে, আপনি এটিকে ^প্রতীক ব্যবহার করে ফ্লাইতে ব্যবহার করতে পারেন । ^'ডি' ভেরিয়েবলগুলির প্রত্যেকটিই একটি যুক্তির সাথে মিলে যায়। (তারা বর্ণানুক্রমিকভাবে বাছাই করা হয়, @^b1 ম আর্গুমেন্ট এবং@^p 2 য়) এই চিহ্নটির একটি ব্যবহারের পরে, আপনি সাধারণত পরিবর্তনশীলটি ব্যবহার করতে পারেন।

বিবৃতিটি কেবল @^bসেখানে বলা আছে যে ব্লকটি বেস পয়েন্ট আর্গুমেন্ট গ্রহণ করবে, যা কেবল বাছাইকরণ ব্লকের অভ্যন্তরে ব্যবহৃত হয়। (অন্যথায় এটি বাছাইকরণ ব্লকের আর্গুমেন্টকে উল্লেখ করবে)) পদ্ধতিতে .sortএকটি যুক্তি লাগতে পারে। যদি এটি 1 টি আর্গুমেন্ট গ্রহণের মতো ব্লক হয় (যেমন এখানে থাকে) তবে অ্যারেরটি সেই ফাংশনের মান অনুসারে বাছাই করা হয়। ব্লক নিজেই প্রতিটি পয়েন্ট পালা করে নেয় এবং Z-বেস পয়েন্ট স্থানাঙ্কের সাথে বিয়োগ ( ) দিয়ে এটি জিপ করে । তারপরে আমরা তালিকার সমস্ত উপাদান বর্গক্ষেত্র »²করে তাদের ব্যবহার করে যোগ করব [+]।

একটি যুক্ত বোনাস হিসাবে, এটি ভাসমান স্থানাঙ্কগুলির সাথেও কাজ করবে এবং যে কোনও মাত্রায় (যতক্ষণ না আপনি স্পষ্টতই, সমস্ত পয়েন্টের জন্য একই সংখ্যক স্থানাঙ্ক সরবরাহ করেন, এটি সঠিক কাজ করে)।

এটি আর বৈধ নয়। আমি এখানে শুধু মজাদার জন্য রেখেছি।

পার্ল 6 , 24 বাইট - কেবল একটি রসিকতা!

{@^b;@^p.sort:{$_!~~@b}}

এটি অনলাইন চেষ্টা করুন!

যেহেতু ওপিতে কোন মেট্রিকটি ব্যবহার করা হবে তা উল্লেখ করা হয়নি, এই জমাটি পৃথক মেট্রিক ব্যবহার করতে পছন্দ করে। এই মেট্রিকটিতে দুটি পয়েন্টের মধ্যে দূরত্ব 0 হয় যদি তারা অভিন্ন হয় এবং 1 না হয় তবে। এটি সত্যই পরীক্ষা করা সহজ যে এটি প্রকৃতপক্ষে একটি মেট্রিক (যদি ρ (A, B) A থেকে B এর দূরত্ব হয় তবে আমাদের এটি প্রয়োজন 1) ρ (A, B) = 0 iff A = B, 2) A (A, B) ) = ρ (বি, এ), ৩) ρ (এ, বি) + ρ (বি, সি) ≥ ρ (এ, সি) ("ত্রিভুজ বৈষম্য"))।

এটি সম্ভবত আরও অনেক গল্ফ করা যেতে পারে, তবে আমি এটি গুরুত্ব সহকারে বলতে চাইছি না।

— Ramillies
সূত্র
জন্য কাজ করে না <5 5 5>,(<5 5 10>,<6 5 5>)। তালিকাগুলি তাদের যোগফল অনুসারে বাছাই করে না তবে উপাদান অনুসারে তুলনা করে। তোমার sumকোথাও দরকার
— nwellnhof
@ ননহ্নহোফ, অনেক ধন্যবাদ আমি কী ভাবছিলাম জানি না ... খুব শীঘ্রই ঠিক হয়ে যাবে।
— Ramillies
2

কোটলিন 1.1, 58 বাইট

{t,i->i.sortedBy{it.zip(t).map{(f,s)->(f-s)*(f-s)}.sum()}}

শোভিত

// t is the target, i is the list of inputs
{ t, i ->
    // Sort the inputs by the distance
    i.sortedBy {
        // For each dimension
        it.zip(t)
            // Calculate the square of the distance
            .map { (f, s) -> (f - s) * (f - s) }
            // Add up the squares
            .sum()
    }
}

পরীক্ষা

var f: (List<Int>, List<List<Int>>) -> List<List<Int>> =
{t,i->i.sortedBy{it.zip(t).map{(f,s)->(f-s)*(f-s)}.sum()}}

data class TestData(val target: List<Int>, val input: List<List<Int>>, val output: List<List<Int>>)

fun main(args: Array<String>) {
    val items = listOf(
            TestData(listOf(5, 5, 5),
                    listOf(listOf(0, 0, 0), listOf(10, 10, 10), listOf(2, 0, 8), listOf(10, 3, 1), listOf(4, 4, 5), listOf(5, 5, 5), listOf(5, 5, 4)),
                    listOf(listOf(5, 5, 5), listOf(5, 5, 4), listOf(4, 4, 5), listOf(2, 0, 8), listOf(10, 3, 1), listOf(0, 0, 0), listOf(10, 10, 10))
            ),
            TestData(listOf(8452, 3160, 6109),
                    listOf(listOf(7172, 5052, 4795), listOf(9789, 4033, 2952), listOf(8242, 213, 3835), listOf(177, 7083, 908), listOf(3788, 3129, 3018), listOf(9060, 464, 2701), listOf(6537, 8698, 291), listOf(9048, 3860, 6099), listOf(4600, 2696, 4854), listOf(2319, 3278, 9825)),
                    listOf(listOf(9048, 3860, 6099), listOf(7172, 5052, 4795), listOf(9789, 4033, 2952), listOf(8242, 213, 3835), listOf(4600, 2696, 4854), listOf(9060, 464, 2701), listOf(3788, 3129, 3018), listOf(2319, 3278, 9825), listOf(6537, 8698, 291), listOf(177, 7083, 908))
            ))
    items.map { it to f(it.target, it.input) }.filter { it.first.output != it.second }.forEach {
        System.err.println(it.first.output)
        System.err.println(it.second)
        throw AssertionError(it.first)
    }
    println("Test Passed")
}
— jrtapsell
সূত্র
2

জাভা 8, 194 + 31 214 169 163 123 112 106 + 19 109 103 বাইট

B->P->P.sort(java.util.Comparator.comparing(p->{int d=0,i=0;while(i<3)d+=(d=p[i]-B[i++])*d;return d;}))

এটি অনলাইন চেষ্টা করুন!

— রবার্তো গ্রাহাম
সূত্র
ভুল ফলাফল: base=[2,3,3], points=[4,3,3],[1,3,4]। আপনার ফলাফলটি [4,3,3], [1,3,4], সঠিক ফলাফলের সময় [1,3,4],[4,3,3]।
— অলিভিয়ার
@ অলিভিগ্রগ্রোওরে ওফস, স্থির
— রবার্তো গ্রাহাম
এর পরিবর্তে প্যারামিটার b->l->{l.sort(java.util.Comparator.comparing(p->{int d=0,i=3;for(;i-->0;)d+=(b[i]-p[i])*(b[i]-p[i]);return d;}));}ধরে ধরে + গল্ফ: (114 বাইট) । List<int[]>int[][]
— অলিভিয়ার গ্রাগোয়ার
1
ওহ, কাস্ট ব্যতীত powকাজ করে +=, বেশিরভাগ ক্ষেত্রে নয়। জেনে ভালো লাগল!
— অলিভিয়ার গ্রাগোয়ার
103 বাইট:B->P->P.sort(java.util.Comparator.comparing(p->{int d=0,i=0;while(i<3)d+=(d=p[i]-B[i++])*d;return d;}))
— নেভে
1

পাইথ, 6 বাইট

o.a,vz

অনলাইনে চেষ্টা করুন: বিক্ষোভ

ব্যাখ্যা:

o.a,vzNQ   implicit variables at the end
o      Q   order the points from the first input line by:
 .a           the euclidean distance between
      N       the point
   ,          and
    vz        the point from the second input line
— Jakube
সূত্র
1
Herokuapp বলেছেন: Bad Request: Request Line is too large (7005 > 4094)। সর্বাধিক লিঙ্কের আকারের জন্য আপনার টেস্ট স্যুটটি ছোট করা উচিত।
— মিঃ এক্সকোডার
@ মিঃ এক্সকোডার ধন্যবাদ আমি এটা ঠিক করেছি.
— জাকুব
1

পার্ল 5 , 90 বাইট

sub v{$i=$t=0;$t+=($_-$p[$i++])**2for pop=~/\d+/g;$t}@p=<>=~/\d+/g;say sort{v($a)<=>v$b}<>

এটি অনলাইন চেষ্টা করুন!

ইনপুট হ'ল নিউলাইনকে পৃথক করে দেওয়া পয়েন্টের তালিকা, প্রথমটির সাথে বেস পয়েন্ট এবং সর্বশেষে শেষের দিকে একটি নতুন পেজ রয়েছে। []স্থানাঙ্কের চারপাশে বন্ধনী ( ) optionচ্ছিক ।

— Xcali
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.