চেবিশেভ রোটেশন


36

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

এখানে চিত্র বর্ণনা লিখুন

সুতরাং উদাহরণস্বরূপ যদি ইনপুট হয় (3, -2)আপনি আউটপুট করা উচিত (3, -1)। দ্রষ্টব্য যে (0, 0)একমাত্র ইনপুট যা নিজের কাছে মানচিত্র করা উচিত।

বিধি

আই / ও ফর্ম্যাটটি যথেষ্ট নমনীয়। আপনি দুটি স্বতন্ত্র সংখ্যা, একটি জোড়া / তালিকা / অ্যারে / সংখ্যার টুপল, একটি একক জটিল সংখ্যা, দুটি সংখ্যাযুক্ত একটি স্ট্রিং ইত্যাদি ব্যবহার করতে পারেন etc.

আপনি এটা ধরে নিতে পারেন -128 < x,y < 128

আপনি কোনও প্রোগ্রাম বা একটি ফাংশন লিখতে পারেন এবং ইনপুট গ্রহণ এবং আউটপুট সরবরাহের আমাদের মানক পদ্ধতির কোনওটি ব্যবহার করতে পারেন ।

আপনি যে কোনও প্রোগ্রামিং ভাষা ব্যবহার করতে পারেন , তবে লক্ষ্য করুন যে এই ফাঁকগুলি ডিফল্টরূপে নিষিদ্ধ করা হয়েছে।

এটি , তাই সংক্ষিপ্ততম বৈধ উত্তর - বাইটগুলিতে মাপা - জয় w

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

(0, 0)       => (0, 0)
(1, 0)       => (1, 1)
(1, 1)       => (0, 1)
(0, 1)       => (-1, 1)
(-1, 1)      => (-1, 0)
(-1, 0)      => (-1, -1)
(-1, -1)     => (0, -1)
(0, -1)      => (1, -1)
(1, -1)      => (1, 0)
(95, -12)    => (95, -11)
(127, 127)   => (126, 127)
(-2, 101)    => (-3, 101)
(-65, 65)    => (-65, 64)
(-127, 42)   => (-127, 41)
(-9, -9)     => (-8, -9)
(126, -127)  => (127, -127)
(105, -105)  => (105, -104)

আমরা কি ইনপুট এবং আউটপুট ফর্ম্যাট মিশ্রিত করতে পারি, উদাহরণস্বরূপ, একটি জটিল সংখ্যা আউটপুট নিতে এবং আউটপুট নিতে পারি?
ডেনিস

@ ডেনিস হ্যাঁ ঠিক আছে।
মার্টিন ইন্ডার

উত্তর:


16

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

কারিটিং সিনট্যাক্সের সাথে ইনপুট নেয় (x)(y)এবং একটি অ্যারে প্রদান করে [new_x, new_y]

x=>y=>(x|y&&((z=x+(y<0))>-y?z>y?y++:x--:z>y?x++:y--),[x,y])

কিভাবে এটা কাজ করে

আমাদের মূল কাজটি হ'ল আমরা কোন চতুর্ভুজটি নির্ধারণ করছি, যাতে আমরা জানতে পারি যে কোন দিকে যেতে হবে।

আমরা প্রথম সূত্র হিসাবে এই সূত্রটি ব্যবহার করতে পারি:

x > -y ? (x > y ? 0 : 1) : (x > y ? 2 : 3)

আমরা যা পাই তা এখানে:

3 1 1 1 1 1 1 1 1
3 3 1 1 1 1 1 1 0
3 3 3 1 1 1 1 0 0
3 3 3 3 1 1 0 0 0
3 3 3 3 3 0 0 0 0
3 3 3 3 2 2 0 0 0
3 3 3 2 2 2 2 0 0
3 3 2 2 2 2 2 2 0
3 2 2 2 2 2 2 2 2

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

z = y < 0 ? x + 1 : x

এবং আমরা আমাদের সূত্র xদিয়ে প্রতিস্থাপন z:

z > -y ? (z > y ? 0 : 1) : (z > y ? 2 : 3)

যা বাড়ে:

3 1 1 1 1 1 1 1 1 
3 3 1 1 1 1 1 1 0 
3 3 3 1 1 1 1 0 0 
3 3 3 3 1 1 0 0 0 
3 3 3 3 3 0 0 0 0 
3 3 3 2 2 0 0 0 0 
3 3 2 2 2 2 0 0 0 
3 2 2 2 2 2 2 0 0 
2 2 2 2 2 2 2 2 0 

পুরো ম্যাট্রিক্স এখন সঠিক, বিশেষ কেস বাদে [0, 0](কোনও পদক্ষেপ নেই) যা আলাদাভাবে সম্বোধন করতে হবে।

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


13

জেলি , 20 14 12 বাইট

S;IṠN0n/¦Ạ¡+

ইনপুট এবং আউটপুট অ্যারে আকারে। এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন

পটভূমি

আমাদের কোন দিকে যেতে হবে তা নির্ধারণ করার জন্য, আমরা প্রারম্ভের বিন্দুটির দ্বিখণ্ডিত x + y = 0 (নীল) এবং x - y = 0 (লাল) এর তুলনামূলক অবস্থানটি পর্যবেক্ষণ করতে পারি ।

নকশা

  • উৎপত্তি স্থির। আমরা শুরুতে [0, 0] যোগ করে অগ্রসর হই by

  • শীর্ষতম ত্রিভুজের বিন্দু - প্রথম চতুর্ভুজ এর দ্বিখণ্ডক সহ - ইতিবাচক যোগফল এবং অ-নেতিবাচক ডেল্টা ( y - x ) থাকে) আমরা শুরুতে [-1, 0] যোগ করে অগ্রসর হই।

  • বামতম ত্রিভুজের পয়েন্টগুলিতে - দ্বিতীয় কোয়াড্রেন্টের দ্বিখণ্ডক সহ - অ-ধনাত্মক যোগফল এবং ধনাত্মক ব-দ্বীপ রয়েছে। আমরা শুরুতে [0, -1] যোগ করে অগ্রসর হই advance

  • তৃতীয় চতুর্ভুজ এর দ্বিখণ্ডক সহ - নীচেরতম ত্রিভুজের বিন্দুগুলিতে নেতিবাচক যোগফল এবং অ-ধনাত্মক ব-দ্বীপ রয়েছে। আমরা শুরুতে [1, 0] যোগ করে অগ্রসর হই।

  • চতুর্থ চতুর্ভুজ এর দ্বিখণ্ডক সহ - ডানদিকের ত্রিভুজের পয়েন্টগুলিতে অ-নেতিবাচক যোগফল এবং নেতিবাচক বদ্বীপ রয়েছে। আমরা শুরুতে [0, 1] যোগ করে অগ্রসর হই।

সঠিক দিকটি বের করার জন্য, আমরা [-sign (x + y), -সাইন (y - x)] গণনা করি , যার কেবলমাত্র নয়টি সম্ভাব্য ফলাফল রয়েছে।

নিম্নলিখিত ফলাফলটি কোন ফলাফলগুলিকে কোন দিকনির্দেশিত করতে হবে তা চিত্রিত করে।

    sign(x+y) |  sign(y-x) | -sign(x+y) | -sign(y-x) |     Δx     |     Δy
  ------------+------------+------------+------------+------------+------------
        0     |      0     |      0     |      0     |      0     |      0
        1     |      0     |     -1     |      0     |     -1     |      0
        1     |      1     |     -1     |     -1     |     -1     |      0
        0     |      1     |      0     |     -1     |      0     |     -1
       -1     |      1     |      1     |     -1     |      0     |     -1
       -1     |      0     |      1     |      0     |      1     |      0
       -1     |     -1     |      1     |      1     |      1     |      0
        0     |     -1     |      0     |      1     |      0     |      1
        1     |     -1     |     -1     |      1     |      0     |      1

এটি তিনটি কেস ছেড়ে দেয়।

  • লক্ষণ অন্তত একটি হয়, তাহলে 0 , [Δx, Δy] = [-sign (এক্স + Y), -sign (yx)]

  • যদি লক্ষণগুলি সমান এবং শূন্য নয়, [Δx, Δy] = [-সাইন (x + y), 0]

  • লক্ষণ ভিন্ন এবং নন-জিরো হন, [Δx, Δy] = [0, -sign (yx)]

কিভাবে এটা কাজ করে

S;IṠN0n/¦Ạ¡+  Main link. Argument: [x, y] (pair of integers)

S             Sum; compute x + y.
  I           Increments; compute [y - x].
 ;            Concatenate; yield [x + y, y - x].
   Ṡ          Sign; compute [sign(x + y), sign(y - x)].
    N         Negate; yield [-sign(x + y), -sign(y - x)].
          ¡   Do n times:
         Ạ      Set n to all([-sign(x + y), -sign(y - x)]), i.e., 1 if the signs
                are both non-zero and 0 otherwise.
        ¦       Conditional application:
      n/          Yield 1 if the signs are not equal, 0 if they are.
     0            Replace the coordinate at 1 or 0 with a 0.
              This returns [Δx, Δy].
           +  Add; yield  [Δx + x, Δy + y].


5

পাইথন, 55 বাইট

lambda x,y:(x-(-y<x<=y)+(y<=x<-y),y+(~x<y<x)-(x<y<=-x))

চারটি তির্যক চতুষ্কোণ সনাক্ত করে এবং যথাযথ স্থানাঙ্ক স্থানান্তর করে।


4

হাস্কেল, 77 71 69 বাইট

x#y|y>=x,-x<y=(x-1,y)|y>x=(x,y-1)|y< -x=(x+1,y)|y<x=(x,y+1)|1>0=(0,0)

এটি কেবল সেই সমস্ত কাতানো কোয়াড্রেন্টগুলির প্রত্যেকটি চেক করছে এবং সে অনুযায়ী ইনপুটটি পরিবর্তন করছে ifying নোট করুন যে স্পেসগুলি প্রয়োজনীয়, অন্যথায় যেমন >-অপারেটর হিসাবে বোঝা যাবে (যা সংজ্ঞায়িত নয়)।

আরও কয়েকটি বাইট অপসারণ করার জন্য @ নিমিকে ধন্যবাদ!


,পরিবর্তে&& প্রথম গার্ডের মধ্যে একটি বাইট সংরক্ষণ করে। এবং তারপরে আপনি দ্বিতীয় -x<yবাইটের সাথে দ্বিতীয় তুলনাটি স্যুইচ করতে পারেন ।
নিমি

ধন্যবাদ, আমি সচেতন ছিলাম না ,!
flawr

4

রুবি, 68

লাম্বদা ফাংশন জটিল সংখ্যাটি আর্গুমেন্ট হিসাবে গ্রহণ করে, জটিল সংখ্যা দেয়।

->z{k=1
4.times{z*=?i.to_c
x,y=z.rect
y*y>=x*x&&y<-x&&(z+=k;k=0)}
z} 

আমরা 90 ডিগ্রি দিয়ে 4 বার দ্বারা গুণ করে পয়েন্টটি ঘোরান i। সুতরাং এটি সমস্ত 4 কোয়াড্রেন্টের মধ্য দিয়ে যায় এবং অপরিবর্তিত অবস্থায় ফিরে আসবে - যখন আমরা তাদের কোনও নির্দিষ্ট ক্ষেত্রে থাকি তখন আমরা এটিকে সংশোধন করি। এটি সর্বদা একই চতুষ্কোণে পরিবর্তিত হয় এই পরিবর্তনটি সহজতর করে।

zডানহ্যান্ড কোয়াড্রেন্টে থাকা অবস্থায় আমরা যদি এটি পরিবর্তন করি তবে তা অনুসরণ করা সহজ । এই ক্ষেত্রে আমরা Y 1 তুল্য বৃদ্ধি প্রয়োজন (অর্থাত যোগ iকরার z।)

আমরা যাচাই x.abs>=y.absবর্গের তুলনা করে xএবং y। এটি আমাদেরকে বলবে যে বিন্দুটি ডানহাতে বা বাম হাতের চতুর্দিকে রয়েছে, উপরের বা নীচে নয়। এটি যাচাই করার জন্য ডানহ্যান্ড চতুর্ভুজটি আসলে আমরা আরও পরীক্ষা করে দেখি x>y(কঠোরতর কারণ আমরা কেসটি বাদ দিতে চাইx=y "শীর্ষ" কোয়াড্র্যান্টের সাথে সম্পর্কিত কেসটি )) এটি সত্য যেখানে আমরা যুক্ত iকরছি z

গল্ফিং কারণে যুক্ত iকরা বাঞ্ছনীয় নয়। পরিবর্তে আমরা সংখ্যাটি সংশোধন করি যখন এটি নীচের চতুষ্কোণে থাকে, সেক্ষেত্রে আমরা xস্থানাঙ্কে 1 যুক্ত করতে হয় (1 যোগ করুন z)) এই ক্ষেত্রে আমরা পরীক্ষা করে দেখি যে y*y>=x*xএটি পরীক্ষা করতে শীর্ষ বা নীচের চতুষ্কোণে রয়েছে। এটি নীচের চতুর্ভুজটিতে রয়েছে তা নিশ্চিত করার জন্য আমাদের পরীক্ষা করা দরকারy<-x (কঠোরভাবে নীচের অংশে ডানদিকে কোণায় যেখানে ক্ষেত্রে ব্যতীত y=-x।)

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

উদাহরণ 1

Input                                        95,-12
Rotate 90deg                                 12,95    
Rotate 90deg                                -95,12    
Rotate 90deg                                -12,-95 
Rotate 90deg                                 95,-12
y.abs>=x.abs=TRUE, y<-x=TRUE, increase x     95,-11

The check and alteration of the coordinate is done AFTER the rotation.
Thus in this case it gets done in the 4th iteration of the loop, not the 1st.
If the code were rewritten to do the check and alteration BEFORE the rotation, 
it would be done in the 1st iteration instead of the 4th.

উদাহরণ 2

Input                                        -1,0
Rotate 90deg                                  0,-1
y.abs>=x.abs=TRUE, y<-x=TRUE, increase x      1,-1
Rotate 90deg                                  1,1
Rotate 90deg                                  1,-1
Rotate 90deg                                 -1,-1
y.abs>=x.abs?=TRUE, y<-x=TRUE but DO NOT CHANGE x!

This is an unusual situation due to the fact that the first move caused the
point to advance by one quadrant. We do NOT want to move it again, for this
reason we need to set k to 0 the first time it is moved.

পরীক্ষা প্রোগ্রামে

f=->z{k=1                   #amount to be added to coordinate
4.times{z*=?i.to_c          #iterate 4 times, rotating point by 90deg till it reaches the original orientation
x,y=z.rect                  #separate out x and y for testing
y*y>=x*x&&y<-x&&(z+=k;k=0)} #if y.abs>=x.abs and y negative and not equal -x, move the point and zero k.
z}                          #return z

puts f[Complex(0, 0)]       # (0, 0)
puts f[Complex(1, 0)]       # (1, 1)
puts f[Complex(1, 1)]       # (0, 1)
puts f[Complex(0, 1)]       # (-1, 1)
puts f[Complex(-1, 1)]      # (-1, 0)
puts
puts f[Complex(-1, 0)]      # (-1, -1)
puts f[Complex(-1, -1)]     # (0, -1)
puts f[Complex(0, -1)]      # (1, -1)
puts f[Complex(1, -1)]      # (1, 0)
puts f[Complex(95, -12)]    # (95, -11)
puts f[Complex(127, 127)]   # (126, 127)
puts
puts f[Complex(-2, 101)]    # (-3, 101)
puts f[Complex(-65, 65)]    # (-65, 64)
puts f[Complex(-127, 42)]   # (-127, 41)
puts f[Complex(-9, -9)]     # (-8, -9)
puts f[Complex(126, -127)]  # (127, -127)
puts f[Complex(105, -105)]  # (105, -104)

নকশা

নিম্নলিখিত চিত্রটি (নীল) সেই অঞ্চলটি যেখানে x*x>=y*y, (হলুদ) সেই ক্ষেত্রটি যেখানে y<-xএবং (সবুজ) এগুলির ছেদটি দেখায় , এটি সেই অঞ্চল যেখানে সঠিক রূপান্তরটি 1 থেকে সংযোজন z

এখানে চিত্র বর্ণনা লিখুন


1
দুঃখিত, আমি ব্যাখ্যা অনুসরণ করছি না। আপনি কোন উদাহরণ বা একটি চিত্র যুক্ত করতে আপত্তি করবেন?
মার্টিন ইন্ডার

@ মার্টিন ব্যাখ্যা যোগ করা হয়েছে। এটি একটি আকর্ষণীয় পন্থা ছিল তবে পয়েন্টগুলির দ্বিগুণ চলাচল দমন করার প্রয়োজনীয়তার কারণে যা তারা প্রথমবারের মতো চতুর্ভুজকে পরিবর্তন করেছিল, আমি আশা করি এটি মার্জিত হয়ে উঠেনি।
স্তর নদী সেন্ট

4

পাইথন, 52 বাইট

h=lambda z:z and 1j*h(z/1j)if'-'in`z*1j-z-1`else z+1

জটিল ইনপুট এবং আউটপুট। নিম্ন তির্যক চতুষ্কোণে অবস্থানের জন্য বিন্দুটি পরীক্ষা করতে, প্রথমে 135 টি ঘড়ির কাঁটার বিপরীত দিকে ঘূর্ণন করে সেই চতুর্ভুজটিকে (x> 0, y> 0) স্ট্যান্ডার্ড কোয়াড্রেন্টে নিয়ে যেতে এবং পরীক্ষার যদি ফলাফলটির স্ট্রিং উপস্থাপনায় কোনও বিয়োগ চিহ্ন না থাকে test 1 টি বিয়োগ করা প্রথম সীমানা শর্ত যত্ন করে।

যদি এটি সেই চতুর্ভুজটিতে না থাকে তবে পুরো সমস্যাটি 90 ডিগ্রি ঘোরান। ইনপুটটি শূন্য হয় নিজেই আউটপুটটিতে বিশেষভাবে পরিচালিত হয়।

জটিল সংখ্যা সহ অন্যান্য প্রচেষ্টা:

## 56 bytes
## Coordinate input, complex output
q=lambda x,y:(y<=x<-y)*(1j*y-~x)or x+1j*y and 1j*q(y,-x)

## 60 bytes
h=lambda z:(z+1)*(z.imag<=z.real<-z.imag)or z and 1j*h(z/1j)

## 63 bytes
from cmath import*
h=lambda z:z and 1j**(phase(z*1j-z)*2//pi)+z

3

গণিত, 34 বাইট

±0=0
±z_:=z+I^Floor[2Arg@z/Pi+3/2]

এটি একটি অযাচিত অপারেটরকে সংজ্ঞায়িত করে ±যা এমন একটি জটিল সংখ্যা নিয়ে যায় এবং ফেরত দেয় যার উপাদানগুলি প্রতিনিধিত্ব করে xএবংy

এখন যে লিন জটিল সংখ্যা সমাধানটি প্রকাশ করেছে এবং ডেনিস আমার স্কোরকে পরাজিত করেছে, আমার গল্ফযুক্ত রেফারেন্স বাস্তবায়ন পোস্ট করার জন্য আমার এত খারাপ লাগছে না। :) (এটি লিনের উত্তরের সাথে কার্যত অভিন্ন বলে প্রমাণিত হয়েছে))


এই সাহায্য করবে? ± 0 = 0 ⁢ ± z_: = z + I ^ ⌊ 2 ⁢ আরগ @ z / পাই + 3/2 ⌋ (সম্ভবত মেঝে বন্ধনীগুলির জন্য আলাদা চর নিয়ে)
ডেভিডসি

@ ডেভিডসি দুর্ভাগ্যক্রমে নয় কারণ তখন আমাকে ইউটিএফ -8 এনকোডিং ব্যবহার করতে হবে এবং তারপরে ± প্রতি 2 বাইটের দাম পড়বে।
মার্টিন ইন্ডার

এটি কি 7 এর পরিবর্তে 4 বাইট হবে না, এভাবে 3 বাইটের অর্থনীতি দেবে?
ডেভিডসি

@ ডেভিডসি নং, মেঝে বন্ধনী প্রতিটি 3 বাইট হবে।
মার্টিন ইন্ডার

আমি এটা সম্পর্কে অবগত ছিল না। তবে, তবুও, আপনার এখনও 1 বাইট সংরক্ষণ করা উচিত।
ডেভিডসি

3

এমএটিএল , 19 17 বাইট

t|?JGJq*X/EYP/k^+

এটি ইনপুট এবং আউটপুট হিসাবে জটিল সংখ্যা ব্যবহার করে।

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন

ব্যাখ্যা

-127+42jএকটি উদাহরণ হিসাবে ইনপুট গ্রহণ করা যাক ।

t|       % Implicit input. Duplicate and take absolute value
         % STACK: -127+42j, 133.764718816286
?        % If nonzero
         % STACK: -127+42j
  J      %   Push j (imaginary unit)
         %   STACK: -127+42j, j
  GJq*   %   Push input multiplied by -1+j. This adds 3*pi/4 to the phase of the input
         %   STACK: -127+42j, j, 85-169i
  X/     %   Phase of complex number
         %   STACK: -127+42j, j, -1.10478465600433
  EYP/   %   Divide by pi/2
         %   STACK: -127+42j, j, -0.703327756220671
  k      %   Round towards minus infinity
         %   STACK: -127+42j, j, -1
  ^      %   Power
         %   STACK: -127+42j, -j
  +      %   Add
         %   STACK: -127+41j
         % Implicit end
         % Implicit display

3

রুবি, 51 বাইট

আসল রূপ

->x,y{d=x*x-y*y
[x+(d>0?0:-y<=>x),y+(d<0?0:x<=>y)]}

এক্সনোরের মন্তব্যে বিকল্প ফর্ম

->x,y{[x+(x*x>y*y ?0:-y<=>x),y+(x*x<y*y ?0:x<=>y)]}

আমার অন্যান্য উত্তরের মতো একই ধরণের বৈষম্য ব্যবহার করে তবে অন্যভাবে।

পরীক্ষা প্রোগ্রামে

f=->x,y{d=x*x-y*y
[x+(d>0?0:-y<=>x), #if y.abs>=x.abs: x+=1 if -y>x, x-=1 if -y<x 
y+(d<0?0:x<=>y)]}  #if x.abs>=y.abs: y+=1 if  x>y, y-=1 if  x<y

p f[0, 0]       # (0, 0)
p f[1, 0]       # (1, 1)
p f[1, 1]       # (0, 1)
p f[0, 1]       # (-1, 1)
p f[-1, 1]      # (-1, 0)
puts
p f[-1, 0]      # (-1, -1)
p f[-1, -1]     # (0, -1)
p f[0, -1]      # (1, -1)
p f[1, -1]      # (1, 0)
p f[95, -12]    # (95, -11)
p f[127, 127]   # (126, 127)
puts
p f[-2, 101]    # (-3, 101)
p f[-65, 65]    # (-65, 64)
p f[-127, 42]   # (-127, 41)
p f[-9, -9]     # (-8, -9)
p f[126, -12]   # (127, -127)
p f[105, -105]  # (105, -104)

কি dনিয়োগ করাটা? দেখে মনে হচ্ছে আপনি কেবল তুলনা করতে পারেন x*x>y*y
xnor

দুর্ভাগ্যক্রমে রুবির একটি স্থানের প্রয়োজন y*yএবং ?এটি ঠিক একই দৈর্ঘ্যের। আমি মনে করি আপনার পথটি কিছু উপায়ে আরও ভাল। আমি মনে করি রুবি এটিকে পাস করার চেষ্টা করছেন y?যা আইনী ফাংশনের নাম হবে।
স্তর নদী সেন্ট

3

জুলিয়া, 38 34 বাইট

!z=z==0?0:z+im^int(2angle(z)/pi+1)

ডেনিস চারটি বাইট সংরক্ষণ করলেন। ধন্যবাদ!

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


দেখে মনে হচ্ছে যে আমি জুলিয়ার বিভিন্ন সংস্করণ জুড়ে ইন্টার -এর আচরণ মিশ্রিত করেছি (যা আমার প্রতিরক্ষা হিসাবে মারাত্মকভাবে বেমানান)। জুলিয়া 0.4 (টিআইও-র সংস্করণ) রাউন্ডগুলি সামনের দিকে অর্ধেক হয়ে যায়, সুতরাং এটি আগের মতো কাজ করবে না। জুলিয়া ০.০ এ, আপনি int(2angle(z)/pi+5)একই বাইট গণনার জন্য ব্যবহার করতে পারেন (negativeণাত্মক শক্তিগুলি যে কোনও কারণেই ত্রুটির কারণ ঘটায়)।
ডেনিস

এছাড়াও, আপনি !z=z+(z!=0)im^...সমস্ত সংস্করণে একটি বাইট সংরক্ষণ করতে পারেন ।
ডেনিস

2

সি ++, 94 বাইট

#define a(x) (x>0?x:-(x))
#define f(x,y) y>a(x-.5)?x--:-y>a(x+.5)?x++:x>a(y+.5)?y++:x|y?y--:x;

Ungolfed:

#define a(x) (x>0?x:-(x))  //shorter than std::abs from <cmath>
#define f(x,y) 
    y>a(x-.5)?      // shift absolute value function by 0.5 to the right to get upper fourth
        x--:
        -y>a(x+.5)? //same for lower fourth
            x++:
            x>a(y+.5)? //same for right fourth
                y++:
                x|y? //only left fourth and 0 are left
                    y--:
                    x; //can't be empty, just does nothing

ব্যবহার:

#include <iostream>
void test(int x, int y, int rx, int ry){
    std::cout << "(" << x << ", " << y << ")=>";
    f(x,y);
    std::cout << "(" << x << ", " << y << ") - " << ((x==rx&&y==ry)?"OK":"FAILURE") << std::endl;
}

//Using the test cases from the question
int main() {
    test(0, 0, 0, 0);
    test(1, 0, 1, 1);
    test(1, 1, 0, 1);
    test(0, 1, -1, 1);
    test(-1, 1, -1, 0);
    test(-1, 0, -1, -1);
    test(-1, -1, 0, -1);
    test(0, -1, 1, -1);
    test(1, -1, 1, 0);
    test(95, -12, 95, -11);
    test(127, 127, 126, 127);
    test(-2, 101, -3, 101);
    test(-65, 65, -65, 64);
    test(-127, 42, -127, 41);
    test(-9, -9, -8, -9);
    test(126, -127, 127, -127);
    test(105, -105, 105, -104);

    return 0;
}

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


আমি নিশ্চিত যে (x>0?x:-(x))এটি হতে পারে (x>0?x:-x)
Yytsi

দুর্ভাগ্যক্রমে নয়, যেহেতু টোকেন এক্স প্রতিস্থাপন করা হবে যেমন x + .5 যা সবে -x + .5 পাবে।
আনেদার

ঠিক আছে। আমার একটি মানসিকতা ছিল যেখানে প্রথম বন্ধনী ছাড়াই
অবহেলা সাইনটি

কড়া কথায় বলতে গেলে আপনি সি প্রিপ্রোসেসর ব্যবহার করেছেন (এটি স্বীকৃতিস্বরূপ সি ++ এর একটি অংশ, তবে অন্যান্য সি রূপগুলি এবং বংশধরদের সাথেও ভাগ করে নেওয়া হয়েছে)
টুকুসি

2

আর, 131 110 বাইট

একটি ক্রিয়া যা দুটি পূর্ণসংখ্যা গ্রহণ করে, x,y ইনপুট হিসাবে এবং আউটপুটকে স্টডআউটে লেখে। সমাধানটি ডেনিসের নিয়ন্ত্রণ প্রবাহের স্কিম অনুসরণ করে তবে সম্ভবত গল্ফ করা যেতে পারে।

সম্পাদনা: @ জেডিএলের পরামর্শের ভিত্তিতে আপডেট হওয়া কোড এবং একগুচ্ছ বাইট সংরক্ষণ করেছে saved

function(x,y){X=sign(x+y);Y=sign(y-x);if(!X|!Y){x=x-X;y=y-Y}else if(X==Y&X&Y)x=x-X else if(X-Y&X)y=y-Y;c(x,y)}

Ungolfed

f=function(x,y){
    X=sign(x+y)                 # calculate sign 
    Y=sign(y-x)                 #  =||=
    if(!X|!Y){x=x-X;y=y-Y}      # if at least one is 0: subtract sign
    else if(X==Y&X&Y)x=x-X      # if signs are equal and non-zero: add sign to x
    else if(X-Y&X)y=y-Y         # if signs are not equal and non-zero: add sign to y
    c(x,y)                      # print to stdout
}

1
আমি মনে করি কিছু যৌক্তিক শর্তকে সংক্ষিপ্ত করা যেতে পারে: as.logical(-1)হ'ল TRUE, তাই X==0|Y==0হতে পারে !X|!Yএবং শর্তটি if(X!=Y...)হয়ে উঠতে পারে if(X-Y)। এছাড়াও, যদি X==Yএবং X!=0তারপর Y!=0অপ্রয়োজনীয় হয়। আসলে, সমস্ত !=0অংশ অপ্রয়োজনীয়; if(X!=0)সমতূল্য if(X)
জেডিএল

1
এছাড়াও, "I / O ফর্ম্যাটটি যথেষ্ট নমনীয়" দেওয়া সত্ত্বেও সম্ভবত এটির c(x,y)পরিবর্তে স্পষ্টতই আউটপুট দেওয়া সুষ্ঠু খেলা cat(x,y)
জেডিএল

@ জেডিএল এগুলি এমন কিছু খুব কার্যকর গল্ফিং টিপস যা আমি কখনই ভাবিনি, ধন্যবাদ অনেক! উত্তর আপডেট করেছেন।
বিলিউব

2

জাভাস্ক্রিপ্ট (ES6), 57 বাইট (55–63 †)

একটি [x, y] অ্যারে গ্রহণ করে, এটি যথাস্থানে সংশোধন করে এবং ফেরত দেয়।

c=>([x,y]=c,i=x>y|x==y&x<0,c[i^x<-y|x==-y]-=-i|!!(x|y),c)

কিভাবে এটা কাজ করে

c=>(

এটি একটি returnফ্রি সংক্ষিপ্ত বডি সহ একক-প্যারামিটার তীর ফাংশন ।

[x,y]=c

পরামিতি অবিলম্বে মধ্যে destructured হয় xএবং yভেরিয়েবল।

,

কমা অপারেটর একের সাথে একাধিক এক্সপ্রেশন একত্রিত করে, শেষের ফলাফলটি ব্যবহার করে।

i=x>y|x==y&x<0

iবৃদ্ধি এবং হ্রাস ক্ষেত্রে পৃথকীকরণের জন্য ব্যবহৃত হয়। যখন এর xচেয়ে বড় হয় y, আমরা নীচের বা ডান চতুর্ভুজ হয়, এবং একটি মাত্রা ( i=1বুলিয়ান থেকে সংখ্যা জোর করে) এগিয়ে যেতে হবে। তেমনিভাবে যখন আমরা বিভাজক x = y তির্যকের নেতিবাচক অংশে থাকি । উত্স সহ অন্যান্য সমস্ত ক্ষেত্রে কোনও বর্ধনের প্রয়োজন হয় না ( i=0)।

c[i^x<-y|x==-y]

কোন অ্যারে সূচকটি সামঞ্জস্য করতে আমরা নিয়ন্ত্রণ করতে কিছুটা অনুরূপ অভিব্যক্তি ব্যবহার করি। আমরা যখন বৃদ্ধিশীল হয় এবং না করে ছেড়ে বা নীচে অর্ধেই (অথবা যখন আমরা হয় না বৃদ্ধিশীল এবং মধ্যে বাম বা নীচে), তারপর, bitwise XOR যাও উত্পাদন করা হবে 1এবং আমরা সামঞ্জস্য হবে Y মান। তেমনিভাবে আমরা যখন বিভাজক x = -y ত্রিভুজটিতে (মূল সহ) for অন্যান্য সমস্ত ক্ষেত্রে সূচকটি হবে 0( এক্স )।

-=-i|!!(x|y)

যখন iহয় 1, আমরা তা নির্দিষ্ট মান যোগ করা হবে। কখন iহয় 0, আমরা 1 থেকে মানটি বাদ দিই যদি এবং কেবলমাত্র আমরা উৎপত্তিস্থলে না থাকি। পরবর্তীটি x|yননজারো উত্পাদন করে সনাক্ত করা যায় , বুলেটিয়ান জবরদস্তি দ্বারা {0, 1 to কেটে যায় এবং এর অবহেলা iআমাদের যুক্তিসঙ্গত পরিবর্তে বিটওয়াইস বা ব্যবহার করতে দেয় (যেহেতু -1কোনও শূন্য বিট নেই, এটি পরিবর্তন থেকে নিরাপদ)।

c

অ্যারে শেষ, তাই এটি ফিরে আসবে।

পরীক্ষামূলক

† প্রকারভেদ

অর্থবহ রিটার্ন মানটি এড়িয়ে এবং কেবল ইনপুট মিউটেশনটি ব্যবহার করে আমরা আরও দুটি বাইট সংরক্ষণ করতে পারি :

c=>([x,y]=c,i=x>y|x==y&x<0,c[i^x<-y|x==-y]-=-i|!!(x|y))

… বা আমরা ইনপুট পরিবর্তনকে এড়িয়ে যেতে পারি এবং ছয় বাইটের ব্যয়ে খাঁটি ফাংশনের জন্য সমস্ত ভেরিয়েবল স্থানীয় করতে পারি:

([x,y],i=x>y|x==y&x<0,c=[x,y])=>(c[i^x<-y|x==-y]-=-i|!!(x|y),c)

1

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

(x,y,s=Math.max(x,y,-x,-y))=>(s?x+s?y-s?x-s?x++:y++:x--:y+s?y--:x++:0,[x,y])

1

হাস্কেল, 53 বাইট

0%0=(0,0)
x%y|y>=0-x,y<x=(x,y+1)|(p,q)<-(-y)%x=(q,-p)

দুটি সংখ্যা নেয়, একটি টিপল আউটপুট দেয়। যদি বিন্দুটি পূর্ব বিভাগে থাকে -x<=y<xতবে দ্বিতীয় স্থানাঙ্কটি ১ দ্বারা বাড়ান Otherwise


1

রেকেট 191 বাইট

(cond[(= 0 x y)(list x y)][(= x y)(if(> x 0)(list(sub1 x)y)(list(add1 x)y))][(> x y)(if(>= x(abs y))
(list x(add1 y))(list(add1 x)y))][(< x y)(if(> y(abs x))(list(sub1 x)y)(list x(sub1 y)))])

অবহেলিত (কোনও অন্তর্বর্তী সূত্র ব্যবহার না করে সরাসরি কোডে চিত্রের দিকনির্দেশগুলি অনুবাদ করা):

(define(f x y)
  (cond
    [(= 0 x y) (list x y)]
    [(= x y)
     (if (> x 0)
         (list (sub1 x) y)   ; left
         (list (add1 x) y))] ; right
    [(> x y)
     (if (>= x (abs y))
         (list x (add1 y))   ; up
         (list (add1 x) y))] ; right
    [(< x y)
     (if (> y (abs x))
         (list (sub1 x) y)   ; left
         (list x (sub1 y)))] ; down
    ))

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

(f 0  0)      
(f 1  0)     
(f 1  1)     
(f 0  1)     
(f -1  1)    
(f -1  0)    
(f -1  -1)   
(f 0  -1)    
(f 1  -1)    
(f 95  -12)  
(f 127  127) 
(f -2  101)  
(f -65  65)  
(f -127  42) 
(f -9  -9)    
(f 126  -127) 
(f 105  -105) 

আউটপুট:

'(0 0)
'(1 1)
'(0 1)
'(-1 1)
'(-1 0)
'(-1 -1)
'(0 -1)
'(1 -1)
'(1 0)
'(95 -11)
'(126 127)
'(-3 101)
'(-65 64)
'(-127 41)
'(-8 -9)
'(127 -127)
'(105 -104)

1

আসলে , 16 বাইট

এটি ইনপুট হিসাবে একটি জটিল সংখ্যা নেয় এবং অন্য জটিল সংখ্যা আউটপুট করে। গল্ফিং পরামর্শ স্বাগত! এটি অনলাইন চেষ্টা করুন!

;`₧╦@/τuLïⁿ+0`╬X

Ungolfing

         Implicit input z.
;        Duplicate z.
`...`╬   If z is non-zero (any a+bi except 0+0j), run the following function.
           Stack: z, z
  ₧        Get phase(z).
  ╦@/      Divide phase(z) by pi.
  τuL      Push floor(2*phase(z)/pi + 1).
  ïⁿ       Push 1j ** floor(2*phase(z)/pi + 1).
  +        And add it to z. This is our rotated z.
  0        Push 0 to end the function.
X        Discard either the duplicate (0+0j) or the 0 from the end of function.
         Implicit return.

0

স্কালা, 184 বাইট

val s=math.signum _
(x:Int,y:Int)=>{val m=x.abs max y.abs
if(x.abs==y.abs)if(s(x)==s(y))(x-s(x),y)else(x,y-s(y))else
if(x.abs==m)(x,y+Seq(0,x).indexOf(m))else(x-Seq(0,y).indexOf(m),y)}

Ungolfed:

import math._

(x: Int, y: Int) => {
  val max = max(x.abs, y.abs)
  if (x.abs == y.abs)
    if (signum(x) == signum(y))
      (x - signum(x), y)
    else
      (x, y - signum(y))
  else
    if (x.abs == max)
      (x, y + Seq(0, x).indexOf(max))
    else
      (x - Seq(0, y).indexOf(max), y)
}

ব্যাখ্যা:

val s=math.signum _             //define s as an alias to math.signum
(x:Int,y:Int)=>{                //define an anonymous function
  val m=x.abs max y.abs           //calculate the maximum of the absolute values,
                                  //which is 1 for the innermost circle and so on.
  if(x.abs==y.abs)                //if we have a cell at a corner of a circle
    if(s(x)==s(y))                  //if it's at the top-left or bottom-right, we need to
                                    //modify the x value
      (x-s(x),y)                      //if x is positive (bottom-right),
                                      //we need to return (x+1,y),
                                      //(x-1,y) If it's at the top-left.
                                      //This can be simplified to (x-s(x),y)
    else                            //for top-right and bottom-left, 
      (x,y-s(y))                      //modify y in the same way.
  else                            //we don't have a corner piece
    if(x.abs==m)                    //if we're at the left or right edge of the square
      (x,y+Seq(0,x).indexOf(m))       //if it's a piece from the right edge, add one
                                      //to y, else subtract 1
    else                            //it's a piece from the top or bottm edge
      (x-Seq(0,y).indexOf(m),y)       //subtract 1 from x if it's from the top edge,
                                      //else subtract -1
}
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.