29

ইনপুট হিসাবে সমতলে 4 পয়েন্ট নেয় এমন ফাংশন লিখুন এবং যদি 4 পয়েন্ট একটি বর্গক্ষেত্র গঠন করে তবে সত্য ফিরে আসে। পয়েন্টগুলির সাথে নিখুঁত মান <1000 এর সাথে অবিচ্ছেদ্য স্থানাঙ্ক থাকবে।

আপনি ইনপুট হিসাবে 4 পয়েন্টের যে কোনও যুক্তিসঙ্গত উপস্থাপনা ব্যবহার করতে পারেন। পয়েন্টগুলি কোনও নির্দিষ্ট ক্রমে সরবরাহ করা হয় না।

সংক্ষিপ্ততম কোড জিতেছে।

বর্গ উদাহরণ:

(0,0),(0,1),(1,1),(1,0)    # standard square
(0,0),(2,1),(3,-1),(1,-2)  # non-axis-aligned square
(0,0),(1,1),(0,1),(1,0)    # different order

অ-স্কোয়ার উদাহরণ:

(0,0),(0,2),(3,2),(3,0)  # rectangle
(0,0),(3,4),(8,4),(5,0)  # rhombus
(0,0),(0,0),(1,1),(0,0)  # only 2 distinct points
(0,0),(0,0),(1,0),(0,1)  # only 3 distinct points

অবনমিত স্কোয়ারের জন্য আপনি সত্য বা মিথ্যা ফিরে আসতে পারেন (0,0),(0,0),(0,0),(0,0)

code-golf math

— কিথ র্যান্ডাল
সূত্র

আমরা এখানে 3D পয়েন্ট কথা বলছি, তাই না?

— gnibbler

3

@gnibbler "এ সমতল" প্রশ্ন করতে 3D অংশ অসম্ভাব্য স্থানটিকে চিহ্নিত করে।

— জেবি

বিন্দুগুলি কি ক্রমানুসারে দেওয়া হয়েছে?

— জেবি

@ জেবি, আমি ভাবছিলাম যে এটির বিন্দুগুলি একটি প্লেনে ছিল, তবে আমি কোনও কারণে 3D স্পেসে একটি প্লেনটি কল্পনা করেছি :)

— gnibbler

1

@ ই বিজনেস: -১ যে আপনি ১১ টি ভোট দিয়েছেন: তাদের মধ্যে 7 টি ডাউন রয়েছে।

— এলেভেক্স

12

পাইথন 176 90 79 বাইট

def S(A):c=sum(A)/4.0;return set(A)==set((A[0]-c)\*1j\*\*i+c for i in range(4))

ফাংশন এস জটিল সংখ্যার একটি তালিকা তার ইনপুট (এ) হিসাবে গ্রহণ করে। আমরা যদি কোনও বর্গক্ষেত্রের কেন্দ্র এবং এক কোণ উভয়ই জানি তবে আমরা কোণটি কেন্দ্র বিন্দু (গ) এর চারপাশে 90,180 এবং 270 ডিগ্রি ঘুরিয়ে বর্গাকারটি পুনর্গঠন করতে পারি। জটিল প্লেনের আবর্তনের প্রায় 90 ডিগ্রি ঘোরার মাধ্যমে i দ্বারা পয়েন্টটি গুণ করে সম্পন্ন করা হয় । যদি আমাদের আসল আকৃতি এবং পুনর্গঠিত বর্গক্ষেত্রের একই পয়েন্ট থাকে তবে অবশ্যই এটি একটি বর্গক্ষেত্র হতে হবে।

— paperhorse
সূত্র

কয়েকটি অপ্টিমাইজেশন: 1) "এস_স্কোয়ার" 2 এর পরিবর্তে "এস" ব্যবহার করুন 2) সমস্ত কিছু এক লাইনে রেখে ব্যবহার করুন; 3) "আমার জন্য (1,1 জে, -1, -1 জে)" 4 এর জন্য 4 দিক থেকে সরাসরি পুনরাবৃত্তি করুন "4) সেট আর্গুমেন্টে প্রয়োজন নেই []।

— কিথ রান্ডাল

ধন্যবাদ কিথ (আমি (3) আমার কোডের সমান দৈর্ঘ্যের বলে মনে হচ্ছে)

— পেপারহর্স

2

@ কিথ র্যান্ডাল - জেবি যখন খুব সংক্ষিপ্ত সমাধান পেয়েছে তখন কেন এটি গৃহীত হয়েছিল?

— আআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআ

1

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

— কিথ র্যান্ডাল

5

@ কীথ র্যান্ডাল - প্রশ্ন থেকে উদ্ধৃতি: "পয়েন্টগুলির মধ্যে সংবিধানের সমন্বয় থাকবে" "সংক্ষিপ্ততম কোড জিতবে" " আপনি যদি কোনও উত্তর বাছাইয়ের জন্য আলাদা মানদণ্ড এমনকি ব্যক্তিগত মানদণ্ড চয়ন করেন তবে এটি পুরোপুরি ঠিক আছে, তবে তারপরে আপনার প্রশ্নের মধ্যে এটি উল্লেখ করা উচিত।

— আআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআ

13

জে, 28 17 25 27

জে'র কার্যত কার্যকারিতা নেই, তবে এখানে একটি মোনাডিক ক্রিয়াটি জটিল প্লেন থেকে পয়েন্টের ভেক্টর গ্রহণ করে:

4 8 4-:#/.~&(/:~&:|&,&(-/~))

পদ্ধতিটি মাইকেল স্পেন্সারের সংমিশ্রণ (এককভাবে আন্ত-প্রান্তিক দৈর্ঘ্যের উপর কাজ করুন; তবে তিনি বর্তমানে আমার রম্বস 2 কে ব্যর্থ করছেন) এবং ইয়েলেক্সের (সেটগুলির আকারগুলি পরীক্ষা করুন) কাজ করে। ডান থেকে বামে পড়া:

-/~ সমস্ত পয়েন্ট পার্থক্য গণনা
, চেপটান
| পরিমাপ
/:~ সাজানো
#/.~ নুন এবং গণনা
4 8 4 -:অবশ্যই 4 টি সমতুল্য (0 এ), 8 টি কিছুটা বড় (দৈর্ঘ্য 1, পক্ষ), 4 টি আরও বড় (দৈর্ঘ্য sqrt 2, ত্রিভুজ) থাকতে হবে

প্রদর্শন:

   NB. give the verb a name for easier use
   f =: 4 8 4-:#/.~&(/:~&:|&,&(-/~))

   NB. standard square
   f 0 0j1 1j1 1
1

   NB. non-axis-aligned square
   f 0 2j1 3j_1 1j_2
1

   NB. different order
   f 0 1j1 0j1 1
1

   NB. rectangle
   f 0 0j2 3j2 3
0

   NB. rhombus 1
   f 0 3j4 8j4 5
0

   NB. rhombus 2
   f 0 1ad_60 1ad0 1ad60
0

স্মৃতিশক্তির জন্য, আমার আগের পদ্ধতিটি (প্রয়োজনীয় অর্ডিক্টস বিভাজনগুলি প্রয়োজনীয়, তবে যে কোনও আদেশের নিয়মিত বহুভুজ সনাক্ত করতে পারে):

*./&(={.)&(%1&|.)&(-1&|.)

ব্যাখ্যা এবং ডেমো জন্য ইতিহাস দেখুন। বর্তমান পদ্ধতিটি সম্ভবত অন্যান্য বহুভুজগুলিতে প্রসারিত হতে পারে, এটি 4 8 4অনেকটা দ্বিপদী বিতরণের মতো দেখায়।

— জেবি
সূত্র

আপনি এই ভাষায় লিঙ্ক করতে পারেন?

— সরগুন illিলন

1

@gnibbler: কেন নয়? আমি এটা নিশ্চিত।

— ইলেভেক্স

1

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

— আআআআআআআআআআআআআআআআআআআআআআআআআআআআ

1

আহ, ঠিক আছে. আমি কেন্দ্রিক হয়ে চতুর্থ দফার সাথে দ্বিপক্ষীয় ত্রিভুজগুলির কথা ভাবছিলাম, তবে এটি পূর্ণসংখ্যার সমন্বয়কারীদের দ্বারা প্রত্যাখ্যান করা হয়

— gnibbler

1

আপনি একটি স্পষ্ট সংজ্ঞা এটিকে পরিবর্তন করে 3 টি অক্ষর কেটে ফেলতে পারেন: 3 :'4 8 4-:#/.~/:~|,-/~y'

— isawdrones

5

পাইথন, 71 42

lambda A: len(set(A))==4 and len(set(abs(i-j)for i in A for j in A))==3

আপডেট 1) 4 টি ভিন্ন পয়েন্টের প্রয়োজন (পূর্বে পুনরাবৃত্ত পয়েন্টগুলির জন্য মিথ্যা ধনাত্মক দিতেন - অন্যগুলি আছে কি?) 2) প্রতি অনুমান অনুযায়ী কোনও ক্রিয়া সংজ্ঞায়িত করতে

একটি বর্গক্ষেত্রের জন্য, যে কোনও দুটি পয়েন্টের মধ্যে ভেক্টর অবশ্যই 0 (একই পয়েন্ট), একটি পাশ বা একটি তির্যক হতে হবে। সুতরাং, এই ভেক্টরগুলির দৈর্ঘ্যের সেটটির দৈর্ঘ্য 3 থাকতে হবে।

# Accepts co-ordinates as sequences of complex numbers

SQUARES=[
 (0+0j,0+1j,1+1j,1+0j),  # standard square
 (0+0j,2+1j,3-1j,1-2j),  # non-axis-aligned square
 (0+0j,1+1j,0+1j,1+0j)   # different order
]

NONSQUARES=[
 (0+0j,0+2j,3+2j,3+0j),  # rectangle
 (0+0j,3+4j,8+4j,5+0j),  # rhombus
 (0+0j,0+1j,1+1j,0+0j),   # duplicated point
 (0+0j,1+60j,1+0j,1-60j)  # rhombus 2 (J B)
] 

test = "lambda A: len(set(A))==4 and len(set(abs(i-j)for i in A for j in A))==3"
assert len(test)==71

is_square=lambda A: len(set(A))==4 and len(set(abs(i-j)for i in A for j in A))==3    

for A in SQUARES:
    assert is_square(A)

for A in NONSQUARES:
    assert not is_square(A)

— mbomb007
সূত্র

আমি মনে করি প্রশ্নটি স্পষ্টভাবে পয়েন্টগুলির একটি তালিকা বলেছিল, এবং কোনও ভেক্টর নয়।

— সরগুন illিলন

মিথ্যা ইতিবাচক.

— aaaaaaaaaaaa

1

সুতরাং (0 + 0 জে, 0 + 0 জ, 1 + 0 জ, 0 + 1 জ) একটি বর্গ?

— মহাগার

আমার রম্বস 2 1 +/- 60j নয়, এটি -1, 0, 1 থেকে মানগুলির জন্য এক্সপ্রেস (i j pi / 3) এর মতো বেশি 1 . প্রশ্নের সুযোগ।

— জেবি

3

হাস্কেল, 100 টি অক্ষর

এখানে আমি হাসকেলে জেবির জে সমাধানটি লিখতে পারি। অযৌক্তিক অক্ষরগুলি সরিয়ে পাঠযোগ্যতার ক্ষতি করার কোনও প্রচেষ্টা না করে এটি প্রায় ১৩২ টি অক্ষর:

import Data.List
d (x,y) (x',y') = (x-x')^2 + (y-y')^2
square xs = (== [4,8,4]) . map length . group . sort $ [d x y | x<-xs, y<-xs]

অতিরিক্ত স্থান সরিয়ে এবং কিছু জিনিস নাম পরিবর্তন করে আপনি এটিকে কিছুটা কমিয়ে 100 এ নামিয়ে দিতে পারেন

import Data.List
d(x,y)(a,b)=(x-a)^2+(y-b)^2
s l=(==[4,8,4]).map length.group.sort$[d x y|x<-l,y<-l]

(এক্স, ওয়াই) এবং প্রান্ত ভেক্টর (ক, খ) এর একটি ভার্টেক্স সহ এটি নির্বিচার স্কোয়ারগুলি গ্রহণ করে তা নিশ্চিত করতে কুইলচেক ব্যবহার করুন:

prop_square (x,y) (a,b) = square [(x,y),(x+a,y+b),(x-b,y+a),(x+a-b,y+b+a)]

GCI এ চেষ্টা করে:

ghci> quickCheck prop_square
*** Failed! Falsifiable (after 1 test):  
(0,0)
(0,0)

ওহ ঠিক আছে, খালি স্কোয়ারটি এখানে বর্গক্ষেত্র হিসাবে বিবেচনা করা হয় না, তাই আমরা আমাদের পরীক্ষাটি সংশোধন করব:

prop_square (x,y) (a,b) =
   (a,b) /= (0,0) ==> square [(x,y),(x+a,y+b),(x-b,y+a),(x+a-b,y+b+a)]

এবং আবার চেষ্টা করে দেখুন:

ghci> quickCheck prop_square
+++ OK, passed 100 tests.

1

ফাংশনটি আনرولল করে 11 টি অক্ষর সংরক্ষণ করুন d। s l=[4,8,4]==(map length.group.sort)[(x-a)^2+(y-b)^2|(x,y)<-l,(a,b)<-l]

— রায়

3

গুণক

ফ্যাক্টর প্রোগ্রামিং ভাষায় একটি বাস্তবায়ন :

USING: kernel math math.combinatorics math.vectors sequences sets ;

: square? ( seq -- ? )
    members [ length 4 = ] [
        2 [ first2 distance ] map-combinations
        { 0 } diff length 2 =
    ] bi and ;

এবং কিছু ইউনিট পরীক্ষা:

[ t ] [
    {
        { { 0 0 } { 0 1 } { 1 1 } { 1 0 } }   ! standard square
        { { 0 0 } { 2 1 } { 3 -1 } { 1 -2 } } ! non-axis-aligned square
        { { 0 0 } { 1 1 } { 0 1 } { 1 0 } }   ! different order
        { { 0 0 } { 0 4 } { 2 2 } { -2 2 } }  ! rotated square
    } [ square? ] all?
] unit-test

[ f ] [
    {
        { { 0 0 } { 0 2 } { 3 2 } { 3 0 } }   ! rectangle
        { { 0 0 } { 3 4 } { 8 4 } { 5 0 } }   ! rhombus
        { { 0 0 } { 0 0 } { 1 1 } { 0 0 } }   ! only 2 distinct points
        { { 0 0 } { 0 0 } { 1 0 } { 0 1 } }   ! only 3 distinct points
    } [ square? ] any?
] unit-test

— mrjbq7
সূত্র

3

ওক্যামেল, 145 ~~164~~

let(%)(a,b)(c,d)=(c-a)*(c-a)+(d-b)*(d-b)
let t a b c d=a%b+a%c=b%c&&d%c+d%b=b%c&&a%b=a%c&&d%c=d%b
let q(a,b,c,d)=t a b c d||t a c d b||t a b d c

এভাবে চালান:

q ((0,0),(2,1),(3,-1),(1,-2))

আসুন deobfuscate এবং কিছু ব্যাখ্যা।

প্রথমে আমরা একটি আদর্শ নির্ধারণ করি:

let norm (ax,ay) (bx,by) = (bx-ax)*(bx-ax)+(by-ay)*(by-ay)

আপনি লক্ষ্য করবেন যে স্কয়ার্টে কোনও কল নেই, এখানে এটির দরকার নেই।

let is_square_with_fixed_layout a b c d =
  (norm a b) + (norm a c) = norm b c
  && (norm d c) + (norm d b) = norm b c
  && norm a b = norm a c
  && norm d c = norm d b

এখানে a, b, c এবং d পয়েন্ট রয়েছে। আমরা ধরে নিই যে এই পয়েন্টগুলি এভাবে ছড়িয়ে দেওয়া হয়েছে:

a - b
| / |
c - d

আমাদের যদি একটি বর্গক্ষেত্র থাকে তবে এই সমস্ত শর্তাদি অবশ্যই ধরে রাখতে হবে:

abc একটি সঠিক ত্রিভুজ
বিসিডি হ'ল একটি ত্রিভুজ
প্রতিটি ডান ত্রিভুজের ছোট দিকগুলির একই মান রয়েছে

নিম্নলিখিত সবসময় ধারণ করে দেখুন:

is_square_with_fixed_layout r s t u = is_square_with_fixed_layout r t s u

আমরা নীচে আমাদের পরীক্ষার কাজটি সহজ করার জন্য এটি ব্যবহার করব।

যেহেতু আমাদের ইনপুটটি অর্ডার করা হয়নি, তাই আমাদের সমস্ত অনুমতিও পরীক্ষা করতে হবে। সাধারণতার ক্ষতি ছাড়াই আমরা প্রথম পয়েন্টটিকে অনুমতি দেওয়া এড়াতে পারি:

let is_square (a,b,c,d) =
  is_square_with_fixed_layout a b c d
  || is_square_with_fixed_layout a c b d
  || is_square_with_fixed_layout a c d b
  || is_square_with_fixed_layout a b d c
  || is_square_with_fixed_layout a d b c
  || is_square_with_fixed_layout a d c b

সরলীকরণের পরে:

let is_square (a,b,c,d) =
  is_square_with_fixed_layout a b c d
  || is_square_with_fixed_layout a c d b
  || is_square_with_fixed_layout a b d c

সম্পাদনা: এম জিওভান্নির পরামর্শ অনুসরণ করেছেন।

— bltxd
সূত্র

খুশী হলাম। আমরা এখানে খুব বেশি

— ওসিএএমএল

এর পরিবর্তে অপারেটর ব্যবহার করুন n 20 অক্ষরের কমানো জন্য: let t a b c d=a%b+a%c=b%c&&d%c+d%b=b%c&&a%b=a%c&&d%c=d%b।

— মাতাস

2

পাইথন (105)

পয়েন্টগুলি (x,y)টিপলস দ্বারা প্রতিনিধিত্ব করা হয় । পয়েন্টগুলি যে কোনও ক্রমে হতে পারে এবং কেবল স্কোয়ার গ্রহণ করে। একটি তালিকা তৈরি করে,sপয়েন্টগুলির মধ্যে জোড়াযুক্ত (শূন্য নয়) দূরত্বের । দুটি অনন্য গ্রুপে মোট 12 দূরত্ব থাকতে হবে।

ডিফ এফ (পি): এস = ফিল্টার (কোনটি নয়, [(এক্সজেড) ** 2+ (ইয়েডাব্লু) ** 2 x এর জন্য x, জ মধ্যে পি, ডাব্লু পি মধ্যে]) রিটার্ন লেন (গুলি) == 12 এবং লেন ( সেট (গুলি)) == 2

— হোয়া লং ট্যাম
সূত্র

আপনি ফিল্টারটি ছাড়তে পারেন এবং সেটটির লেনটি 3 কিনা তা পরীক্ষা করতে পারেন যদিও এটি আমার উত্তর হিসাবে একই মিথ্যা ইতিবাচক সমস্যাটি ভুগছে।

— gnibbler

>>> f ([(0,0), (0,4), (2,2), (- 2,2)]) = সত্য

— সরগুন illিলন

2

f([(0,0),(0,4),(2,2),(-2,2)]) একটি বর্গক্ষেত্র হয়

— gnibbler

2

পাইথন - 42 টি অক্ষর

পয়েন্টগুলির জন্য জটিল সংখ্যা ব্যবহার করার জন্য এটির উন্নতি বলে মনে হচ্ছে

len(set(abs(x-y)for x in A for y in A))==3

যেখানে এ = [(11 + 13 জে), (14 + 12 জ), (13 + 9 জ), (10 + 10 জ)]

পুরানো উত্তর:

from itertools import*
len(set((a-c)**2+(b-d)**2 for(a,b),(c,d)in combinations(A,2)))==2

পয়েন্টগুলি কোনও ক্রমে তালিকা হিসাবে নির্দিষ্ট করা হয়, যেমন

A = [(11, 13), (14, 12), (13, 9), (10, 10)]

— gnibbler
সূত্র

>>> A=[(0,0),(0,0),(1,1),(0,0)] >>> len(set((a-c)**2+(b-d)**2 for(a,b),(c,d)in combinations(A,2)))==2 True

— সরগুন illিলন

@ সরগুন, এটি পুরো ক্লাসের ইনপুটগুলির বিশেষ কাজ যা কাজ করে না। আমি এমন একটি ফিক্সের কথা চিন্তা করার চেষ্টা করছি যা উত্তরের আকারটি বের করে না। এদিকে, ব্যর্থ মামলার সাধারণ শ্রেণি কি কাজ করতে পারে?

— gnibbler

A=[(0,0),(0,4),(2,2),(-2,2)]; len(set((a-c)**2+(b-d)**2 for(a,b),(c,d)in combinations(A,2)))==2

— সরগুন illিলন

@ সরগুন: উদাহরণটি একটি বর্গক্ষেত্র।

— কিথ র্যান্ডাল

সদৃশ পয়েন্টগুলি থেকে মুক্তি পেতে আপনি -set ([0]) যোগ করতে পারেন

— কিথ র্যান্ডাল

2

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

var points = new List<Point>
             {
                 new Point( 0, 0 ), 
                 new Point( 3, 4 ), 
                 new Point( 8, 4 ), 
                 new Point( 5, 0 )
              };    
var distances = points.SelectMany(
    (value, index) => points.Skip(index + 1),
    (first, second) => new Tuple<Point, Point>(first, second)).Select(
        pointPair =>
        Math.Sqrt(Math.Pow(pointPair.Item2.X - pointPair.Item1.X, 2) +
                Math.Pow(pointPair.Item2.Y - pointPair.Item1.Y, 2)));
return
    distances.Any(
        d => distances.Where( p => p == d ).Count() == 4 &&
                distances.Where( p => p != d ).Distinct().Count() == 1 );

— ড্যানিয়েল কফম্যান
সূত্র

2

পিএইচপি, 82 টি অক্ষর

//$x=array of x coordinates
//$y=array of respective y coordinates
/* bounding box of a square is also a square - check if Xmax-Xmin equals Ymax-Ymin */
function S($x,$y){sort($x);sort($y);return ($x[3]-$x[0]==$y[3]-$y[0])?true:false};

//Or even better (81 chars):
//$a=array of points - ((x1,y1), (x2,y2), (x3,y3), (x4,y4))
function S($a){sort($a);return (bool)($a[3][0]-$a[0][0]-abs($a[2][1]-$a[3][1]))};

— arek
সূত্র

তবে কেবল বাউন্ডিং বক্সটি বর্গক্ষেত্রের অর্থ পয়েন্টগুলি কোনও স্কোয়ারে থাকা নয় lie প্রয়োজনীয় তবে পর্যাপ্ত শর্ত নয়। (0,0), (5,5), (10,0), (0, -5) বিবেচনা করুন। বাউন্ডিং বক্সটি বর্গাকার (0:10, -5: 5); ফিগার হয় না।

— ফ্লোরিস

2

কে - 33

জেবি দ্বারা জে সমাধানটির অনুবাদ :

{4 8 4~#:'=_sqrt+/'_sqr,/x-/:\:x}

কে এখানে তার সংরক্ষিত শব্দ ( _sqrএবং _sqrt) থেকে ভোগে ।

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

  f:{4 8 4~#:'=_sqrt+/'_sqr,/x-/:\:x}

  f (0 0;0 1;1 1;1 0)
1

  f 4 2#0 0 1 1 0 1 1 0
1

  f 4 2#0 0 3 4 8 4 5 0
0

— isawdrones
সূত্র

2

OCaml + ব্যাটারি, 132 টি অক্ষর

let q l=match List.group(-)[?List:(x-z)*(x-z)+(y-t)*(y-t)|x,y<-List:l;z,t<-List:l;(x,y)<(z,t)?]with[[s;_;_;_];[d;_]]->2*s=d|_->false

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

পরীক্ষা:

q [(0,0);(0,1);(1,1);(1,0)] ;;
- : bool = true
q [(0,0);(2,1);(3,-1);(1,-2)] ;;
- : bool = true
q [(0,0);(1,1);(0,1);(1,0)] ;;
- : bool = true
q [(0,0);(0,2);(3,2);(3,0)] ;;
- : bool = false
q [(0,0);(3,4);(8,4);(5,0)] ;;
- : bool = false
q [(0,0);(0,0);(1,1);(0,0)] ;;
- : bool = false
q [(0,0);(0,0);(1,0);(0,1)] ;;
- : bool = false

— মাতাস জিয়োভানিনী
সূত্র

2

গণিত 65 65 69 66

স্বতন্ত্র আন্তঃ-পয়েন্ট দূরত্বের সংখ্যা (একটি বিন্দু থেকে নিজের থেকে দূরত্ব অন্তর্ভুক্ত নয়) 2 এবং দুটিটির সংক্ষিপ্ত 0 নয় Che

h = Length@# == 2 \[And] Min@# != 0 &[Union[EuclideanDistance @@@ Subsets[#, {2}]]] &;

ব্যবহার

h@{{0, 0}, {0, 1}, {1, 1}, {1, 0}}       (*standard square *)
h@{{0, 0}, {2, 1}, {3, -1}, {1, -2}}     (*non-axis aligned square *)
h@{{0, 0}, {1, 1}, {0, 1}, {1, 0}}       (*a different order *)

h@{{0, 0}, {0, 2}, {3, 2}, {3, 0}}       (* rectangle *)
h@{{0, 0}, {3, 4}, {8, 4}, {5, 0}}       (* rhombus   *)
h@{{0, 0}, {0, 0}, {1, 1}, {0, 0}}       (* only 2 distinct points *)
h@{{0, 0}, {0, 1}, {1, 1}, {0, 1}}       (* only 3 distinct points *)

সত্য
সত্য
সত্য
মিথ্যা
মিথ্যা
মিথ্যা
মিথ্যা

এনবি: গাণিতিকের \[And]একটি চরিত্র character

— DavidC
সূত্র

1

আপনি কি আমাকে বলছেন যে ম্যাথামেটিকায় অন্তর্নির্মিত ইস্কোয়ার ফাংশন নেই?

— গুডগুয়ে

2

জেলি , 8 বাইট

_Æm×ıḟƊṆ

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

কম্যান্ড লাইন আর্গুমেন্ট হিসাবে জটিল সংখ্যার একটি তালিকা নেয়। প্রিন্ট 1বা0 ।

_Æm        Subtract mean of points from each point (i.e. center on 0)
   ×ıḟƊ    Rotate 90°, then compute set difference with original.
       Ṇ   Logical negation: if empty (i.e. sets are equal) then 1 else 0.

এটিকে পুনরুদ্ধার করার মতো উপভোগ্য চ্যালেঞ্জ বলে মনে হচ্ছে!

— লিন
সূত্র

1

হাস্কেল (212)

import Data.List;j=any f.permutations where f x=(all g(t x)&&s(map m(t x)));t x=zip3 x(drop 1$z x)(drop 2$z x);g(a,b,c)=l a c==sqrt 2*l a b;m(a,b,_)=l a b;s(x:y)=all(==x)y;l(m,n)(o,p)=sqrt$(o-m)^2+(n-p)^2;z=cycle

নিষ্পাপ প্রথম প্রচেষ্টা। পয়েন্টগুলির ইনপুট তালিকার সমস্ত ক্রিয়াকলাপের জন্য নিম্নলিখিত দুটি শর্ত পরীক্ষা করে (যেখানে প্রদত্ত ক্রমান্বয়ে প্রতিনিধিত্ব করে, বলে, পয়েন্টগুলির ঘড়ির কাঁটার ক্রম)

সমস্ত কোণ 90 ডিগ্রি হয়
সমস্ত পক্ষ একই দৈর্ঘ্য

Deobfuscated কোড এবং পরীক্ষা

j' = any satisfyBothConditions . permutations
          --f
    where satisfyBothConditions xs = all angleIs90 (transform xs) && 
                                     same (map findLength' (transform xs))
          --t
          transform xs = zip3 xs (drop 1 $ cycle xs) (drop 2 $ cycle xs)
          --g
          angleIs90 (a,b,c) = findLength a c == sqrt 2 * findLength a b
          --m
          findLength' (a,b,_) = findLength a b
          --s
          same (x:xs) = all (== x) xs
          --l
          findLength (x1,y1) (x2,y2) = sqrt $ (x2 - x1)^2 + (y2 - y1)^2


main = do print $ "These should be true"
          print $ j [(0,0),(0,1),(1,1),(1,0)]
          print $ j [(0,0),(2,1),(3,-1),(1,-2)]
          print $ j [(0,0),(1,1),(0,1),(1,0)]
          print $ "These should not"
          print $ j [(0,0),(0,2),(3,2),(3,0)]
          print $ j [(0,0),(3,4),(8,4),(5,0)]
          print $ "also testing j' just in case"
          print $ j' [(0,0),(0,1),(1,1),(1,0)]
          print $ j' [(0,0),(2,1),(3,-1),(1,-2)]
          print $ j' [(0,0),(1,1),(0,1),(1,0)]
          print $ j' [(0,0),(0,2),(3,2),(3,0)]
          print $ j' [(0,0),(3,4),(8,4),(5,0)]

— ড্যান বার্টন
সূত্র

1

স্কালা (১৪6 টি অক্ষর)

def s(l:List[List[Int]]){var r=Set(0.0);l map(a=>l map(b=>r+=(math.pow((b.head-a.head),2)+math.pow((b.last-a.last),2))));print(((r-0.0).size)==2)}

— গ্যারেথ
সূত্র

1

জাভাস্ক্রিপ্ট ১৪৪ টি অক্ষর

জে বিএস উত্তরের গাণিতিকভাবে সমান। এটি 6 দৈর্ঘ্য উত্পন্ন করে এবং জোর দেয় যে 2 টি বৃহত্তর সমান এবং 4 টি সবচেয়ে ছোট সমান। ইনপুট অবশ্যই অ্যারের অ্যারে হতে হবে।

function F(a){d=[];g=0;for(b=4;--b;)for(c=b;c--;d[g++]=(e*e+f*f)/1e6)e=a[c][0]-a[b][0],f=a[c][1]-a[b][1];d.sort();return d[0]==d[3]&&d[4]==d[5]} //Compact function
testcases=[
[[0,0],[1,1],[1,0],[0,1]],
[[0,0],[999,999],[999,0],[0,999]],
[[0,0],[2,1],[3,-1],[1,-2]],
[[0,0],[0,2],[3,2],[3,0]],
[[0,0],[3,4],[8,4],[5,0]],
[[0,0],[0,0],[1,1],[0,0]],
[[0,0],[0,0],[1,0],[0,1]]
]
for(v=0;v<7;v++){
    document.write(F(testcases[v])+"<br>")
}

function G(a){ //Readable version
    d=[]
    g=0
    for(b=4;--b;){
        for(c=b;c--;){
            e=a[c][0]-a[b][0]
            f=a[c][1]-a[b][1]
            d[g++]=(e*e+f*f)/1e6 //The division tricks the sort algorithm to sort correctly by default method.
        }
    }
    d.sort()
    return (d[0]==d[3]&&d[4]==d[5])
}

— aaaaaaaaaaaa
সূত্র

1

পিএইচপি, 161 158 টি অক্ষর

function S($a){for($b=4;--$b;)for($c=$b;$c--;){$e=$a[$c][0]-$a[$b][0];$f=$a[$c][1]-$a[$b][1];$d[$g++]=$e*$e+$f*$f;}sort($d);return$d[0]==$d[3]&&$d[4]==$d[5];}

প্রুফ (1x1): http://codepad.viper-7.com/ZlBpOB

এটি ইবুইসনেসের জাভাস্ক্রিপ্ট উত্তরের ভিত্তিতে তৈরি ।

— কেভিন ব্রাউন
সূত্র

সমস্যা বিবরণী থেকে পয়েন্টগুলি যথাযথভাবে আসবে এটি থেকে কিছুটা অস্পষ্ট। আমি জিজ্ঞাসা করতে যাব।

— জেবি

1

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

— কীথ র্যান্ডাল

জাভাস্ক্রিপ্টের উত্তরগুলির একটির সাথে মেলে এটি আপডেট করেছে, সমস্ত ক্ষেত্রে পরিচালনা করা উচিত।

— কেভিন ব্রাউন

1

জাভাস্ক্রিপ্ট 1.8, 112 টি অক্ষর

আপডেট: অ্যারে বোঝার এক সাথে ভাঁজ করে 2 টি অক্ষর সংরক্ষণ করা হয়েছে।

function i(s)(p=[],[(e=x-a,f=y-b,d=e*e+f*f,p[d]=~~p[d]+1)for each([a,b]in s)for each([x,y]in s)],/8,+4/.test(p))

জাবির উত্তরের আর একটি সংশোধনী। জাভাস্ক্রিপ্ট 1.7 / 1.8 বৈশিষ্ট্য (এক্সপ্রেশন ক্লোজার্স, অ্যারে বোঝাপড়া, ডিস্ট্রাকচারিং অ্যাসাইনমেন্ট) শোষণ করে। এছাড়াও অ্যারে-টু-স্ট্রিং জবরদস্তি এবং দৈর্ঘ্য গণনাগুলি পরীক্ষা করে পরীক্ষা করার জন্য একটি রেজিএক্সপ্যাকের সাথে ~~(ডাবল বিটওয়াইজ অপারেটর নয় অপারেটর) অপব্যবহার ( এটি ধরে নেওয়া হয় যে 4 টি পয়েন্ট উত্তীর্ণ হয়েছে)। কমা অপারেটরের অপব্যবহার হ'ল একটি পুরানো অবহেলিত সি ট্রিক।undefined[4, 8, 4]

পরীক্ষা:

function assert(cond, x) { if (!cond) throw ["Assertion failure", x]; }

let text = "function i(s)(p=[],[(e=x-a,f=y-b,d=e*e+f*f,p[d]=~~p[d]+1)for each([a,b]in s)for each([x,y]in s)],/8,+4/.test(p))"
assert(text.length == 112);
assert(let (source = i.toSource()) (eval(text), source == i.toSource()));

// Example squares:
assert(i([[0,0],[0,1],[1,1],[1,0]]))    // standard square
assert(i([[0,0],[2,1],[3,-1],[1,-2]]))  // non-axis-aligned square
assert(i([[0,0],[1,1],[0,1],[1,0]]))    // different order

// Example non-squares:
assert(!i([[0,0],[0,2],[3,2],[3,0]]))  // rectangle
assert(!i([[0,0],[3,4],[8,4],[5,0]]))  // rhombus
assert(!i([[0,0],[0,0],[1,1],[0,0]]))  // only 2 distinct points
assert(!i([[0,0],[0,0],[1,0],[0,1]]))  // only 3 distinct points

// Degenerate square:
assert(!i([[0,0],[0,0],[0,0],[0,0]]))   // we reject this case

— ecatmur
সূত্র

1

GoRuby - 66 টি অক্ষর

f=->a{z=12;a.pe(2).m{|k,l|(k-l).a}.so.go{|k|k}.a{|k,l|l.sz==z-=4}}

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

f=->a{z=12;a.permutation(2).map{|k,l|(k-l).abs}.sort.group_by{|k|k}.all?{|k,l|l.size==(z-=4)}}

জেবির উত্তর হিসাবে একই অ্যালগরিদম ।

পরীক্ষা যেমন:

p f[[Complex(0,0), Complex(0,1), Complex(1,1), Complex(1,0)]]

trueসত্যের ফলাফল এবং মিথ্যা জন্য ফাঁকা

— Nemo157
সূত্র

গোরুবির কথা কখনও শুনেনি। এটি নিয়ে কি কোনও আধিকারিক লেখা আছে? stackoverflow.com/questions/63998/hided-features-of-ruby/…

— জোনাস এলফস্ট্রাম

@Jonas: আমি কিছুই এটি সম্পর্কে সত্যিই কর্মকর্তা দেখিনি, সেরা ব্লগ পোস্ট আমি দেখেছি হয় এই এক । আমি এটি তৈরি এবং কাজ করতে আসলে সক্ষম ছিলাম না তবে এর বিকল্প হ'ল গল্ফ-ruby -r ./golf-prelude.rb FILE_TO_RUN.rb প্রিলিওডটিকে একই ফোল্ডারে অনুলিপি করা এবং চালানো এবং এটি একইভাবে কাজ করবে।

— নিমো 157

এটি sortআগে প্রয়োজন হয় না group_by। .sort.group_by {...}এভাবে লিখতে হবে.group_by {...}

— user102008

1

পাইথন 97 (জটিল পয়েন্ট ছাড়া)

def t(p):return len(set(p))-1==len(set([pow(pow(a-c,2)+pow(b-d,2),.5)for a,b in p for c,d in p]))

এটি যে কোনও ক্রমে [(x, y), (x, y), (x, y), (x, y)] পয়েন্ট টিপলগুলির তালিকা নেবে এবং সদৃশ বা পয়েন্টের ভুল সংখ্যাকে পরিচালনা করতে পারে। অন্যান্য অজগর উত্তরের মতো এর জন্য জটিল পয়েন্টের প্রয়োজন নেই।

আপনি এটি পরীক্ষা করতে পারেন:

S1 = [(0,0),(1,0),(1,1),(0,1)]   # standard square
S2 = [(0,0),(2,1),(3,-1),(1,-2)] # non-axis-aligned square
S3 = [(0,0),(1,1),(0,1),(1,0)]   # different order
S4 = [(0,0),(2,2),(0,2),(2,0)]   #
S5 = [(0,0),(2,2),(0,2),(2,0),(0,0)] #Redundant points

B1 = [(0,0),(0,2),(3,2),(3,0)]  # rectangle
B2 = [(0,0),(3,4),(8,4),(5,0)]  # rhombus
B3 = [(0,0),(0,0),(1,1),(0,0)]  # only 2 distinct points
B4 = [(0,0),(0,0),(1,0),(0,1)]  # only 3 distinct points
B5 = [(1,1),(2,2),(3,3),(4,4)]  # Points on the same line
B6 = [(0,0),(2,2),(0,2)]        # Not enough points

def tests(f):
    assert(f(S1) == True)
    assert(f(S2) == True)
    assert(f(S3) == True)
    assert(f(S4) == True)
    assert(f(S5) == True)

    assert(f(B1) == False)
    assert(f(B2) == False)
    assert(f(B3) == False)
    assert(f(B4) == False)
    assert(f(B5) == False)
    assert(f(B6) == False)

def t(p):return len(set(p))-1==len(set([pow(pow(a-c,2)+pow(b-d,2),.5)for a,b in p for c,d in p]))

tests(t)

এটি কিছুটা ব্যাখ্যা করে নেবে, তবে সামগ্রিক ধারণাটি হল যে একটি বর্গক্ষেত্রে পয়েন্টগুলির মধ্যে কেবল তিনটি দূরত্ব রয়েছে (সাইড, ডায়াগোনাল, জিরো (নিজের সাথে তুলনা করা পয়েন্ট)):

def t(p):return len(set(p))-1==len(set([pow(pow(a-c,2)+pow(b-d,2),.5)for a,b in p for c,d in p]))

টিপলগুলির একটি তালিকা পি এর জন্য (x, y)
সেট (পি) ব্যবহার করে সদৃশগুলি সরান এবং তারপরে দৈর্ঘ্যটি পরীক্ষা করুন
প্রতিটি পয়েন্টের সংমিশ্রণ পান (a, b এর জন্য p, d এর জন্য পি)
প্রতিটি বিন্দু থেকে প্রতিটি পয়েন্টে দূরত্বের তালিকা পান
মাত্র তিনটি অনন্য দূরত্ব রয়েছে তা পরীক্ষা করতে সেট ব্যবহার করুন - জিরো (নিজের তুলনায় পয়েন্ট) - পার্শ্ব দৈর্ঘ্য - তির্যক দৈর্ঘ্য

কোডের অক্ষরগুলি সংরক্ষণ করতে আমি আছি:

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

আমি আশঙ্কা করি যে কেউ এই পরীক্ষার কেস খুঁজে পেতে পারে যা এটি ভেঙে যায়। সুতরাং দয়া করে এবং সঠিক করুন। উদাহরণস্বরূপ, আমি কেবল তিনটি দূরত্ব পরীক্ষা করি, পরিবর্তে একটি অ্যাবস () না করে পাশের দৈর্ঘ্য এবং হাইপোপেনিউস পরীক্ষা করে, এটি একটি ত্রুটি বলে মনে হয়।

প্রথমবার আমি কোড গল্ফ চেষ্টা করেছি। আমি যদি বাড়ির কোনও নিয়ম ভঙ্গ করে থাকি তবে সদয় হন।

— Jagu
সূত্র

1

ক্লোজার, 159 অক্ষর।

user=> (def squares
         [[[0,0] [0,1] [1,1]  [1,0]]   ; standard square
         [[0,0] [2,1] [3,-1] [1,-2]]  ; non-axis-aligned square
         [[0,0] [1,1] [0,1]  [1,0]]]) ; different order
#'user/squares
user=> (def non-squares
         [[[0,0] [0,2] [3,2] [3,0]]    ; rectangle
          [[0,0] [3,4] [8,4] [5,0]]])  ; rhombus
#'user/non-squares
user=> (defn norm
         [x y]
         (reduce + (map (comp #(* % %) -) x y)))
#'user/norm
user=> (defn square?
         [[a b c d]]
         (let [[x y z] (sort (map #(norm a %) [b c d]))]
           (and (= x y) (= z (* 2 x)))))
#'user/square?
user=> (every? square? squares)
true
user=> (not-any? square? non-squares)
true

সম্পাদনা করুন: কিছুটা ব্যাখ্যা করার জন্য।

প্রথমে একটি আদর্শ নির্ধারণ করুন যা মূলত দুটি প্রদত্ত পয়েন্টের মধ্যে দূরত্ব দেয়।
তারপরে অন্য তিনটি পয়েন্টের প্রথম বিন্দুর দূরত্ব গণনা করুন।
তিনটি দূরত্বে বাছাই করুন। (এটি বিন্দুগুলির কোনও ক্রমকে মঞ্জুরি দেয়))
দুটি সংক্ষিপ্ততম দূরত্ব অবশ্যই বর্গক্ষেত্রের সমান হতে হবে।
তৃতীয় (দীর্ঘতম) দূরত্বটি পাইথাগোরসের উপপাদ্য দ্বারা সংক্ষিপ্ত দূরত্বে বর্গাকার যোগফলের বর্গমূলের সমান হতে হবে।

(দ্রষ্টব্য: স্কোয়ার রুট করার প্রয়োজন নেই এবং তাই উপরের কোডে সংরক্ষণ করা হয়েছে))

— Meikel
সূত্র

1

সি #, 107 টি অক্ষর

return p.Distinct().Count()==4&&
(from a in p from b in p select (a-b).LengthSquared).Distinct().Count()==3;

যেখানে পয়েন্টগুলি পয়েন্টগুলি সহ ভেক্টর 3 ডি এর তালিকা।

সমস্ত পয়েন্টের মধ্যে বর্গক্ষেত্রের সমস্ত দূরত্বকে গণনা করে এবং ঠিক তিনটি স্বতন্ত্র প্রকারের (অবশ্যই 0, কিছু মান a, এবং 2 * a) এবং 4 টি স্বতন্ত্র পয়েন্ট থাকে তবে পয়েন্টগুলি একটি বর্গ গঠন করে।

— আপনি
সূত্র

1

পাইথন, 66

To 76 থেকে from 66 পর্যন্ত পেপারহর্সের উত্তর উন্নত করা :

def U(A):c=sum(A)/4;d=A[0]-c;return{d+c,c-d,d*1j+c,c-d*1j}==set(A)

— মনিকা পুনরায় স্থাপন করুন
সূত্র

1

পাইথন 2 , 49 বাইট

lambda l:all(1j*z+(1-1j)*sum(l)/4in l for z in l)

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

ইনপুট হিসাবে চারটি জটিল সংখ্যার একটি তালিকা নেয়। প্রতিটি পয়েন্টকে গড়ে প্রায় 90 ডিগ্রি ঘোরায় এবং প্রতিটি ফলাফল পয়েন্টটি মূল তালিকায় রয়েছে কিনা তা পরীক্ষা করে।

একই দৈর্ঘ্য (যদিও পাইথন 3 ব্যবহারের ক্ষেত্রে ছোট {*l})।

lambda l:{1j*z+(1-1j)*sum(l)/4for z in l}==set(l)

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

— xnor
সূত্র

অল্প হলে পাইথন 3 ব্যবহার করবেন না কেন? এছাড়াও, যদি পাইথনে নির্বিচারে সত্যবাদী / মিথ্যা মানগুলি ফেরত দেওয়ার অনুমতি দেওয়া হয় তবে তার ^পরিবর্তে ব্যবহার করা যেতে পারে ==।

— জোয়েল

@ জোয়েল পাইথন 2 বেশিরভাগ ক্ষেত্রে অগ্রাধিকার, এবং এটি ২০১১ সালের সত্যিকারের পুরানো চ্যালেঞ্জ, যখন পাইথন 2 পাইথনকে গল্ফিংয়ের দিকে নিয়েছিল। এবং চ্যালেঞ্জটি সত্য বা মিথ্যা ফিরে আসতে বলে, তাই আমি এটি দিয়ে আটকেছি। এটি যদি আজ পোস্ট করা হয় তবে এটি সম্ভবত আউটপুট সত্যতা / মিথ্যা বা দুটি স্বতন্ত্র মানগুলির একটি নির্দিষ্ট করে এবং এটি ডিফল্টরূপে ধরে নেওয়াও ঠিক আছে।

— xnor

1

ওল্ফ্রাম ভাষা (গণিত) , 32 31 বাইট

Tr[#^2]==Tr[#^3]==0&[#-Mean@#]&

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

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

আন golfed:

S[p_] := Total[(p - Mean[p])^2] == Total[(p - Mean[p])^3] == 0

অথবা

S[p_] := CentralMoment[p, 2] == CentralMoment[p, 3] == 0

প্রমাণ

এই মানদণ্ডটি কেবল গসিয়ান পূর্ণসংখ্যায় নয়, পুরো জটিল বিমানটিতে কাজ করে ।

প্রথমে, আমরা লক্ষ করি যে পয়েন্টগুলি এক সাথে অনুবাদ করা হলে কেন্দ্রীয় মুহুর্তগুলি পরিবর্তন হয় না। পয়েন্ট একটি সেট জন্য
```
P = Table[c + x[i] + I*y[i], {i, 4}]
```
কেন্দ্রীয় মুহূর্তগুলি সমস্তই স্বতন্ত্র c(সে কারণেই এগুলিকে কেন্দ্রীয় বলা হয় ):
```
{FreeQ[FullSimplify[CentralMoment[P, 2]], c], FreeQ[FullSimplify[CentralMoment[P, 3]], c]}
(*    {True, True}    *)
```
দ্বিতীয়ত, কেন্দ্রীয় মুহুর্তগুলিতে পয়েন্টগুলির সেটের সামগ্রিক জটিল স্কেলিং (স্কেলিং এবং রোটেশন) এর উপর একটি সাধারণ নির্ভরতা থাকে:
```
P = Table[f * (x[i] + I*y[i]), {i, 4}];
FullSimplify[CentralMoment[P, 2]]
(*    f^2 * (...)    *)
FullSimplify[CentralMoment[P, 3]]
(*    f^3 * (...)    *)
```
এর অর্থ হ'ল যদি কোনও কেন্দ্রীয় মুহূর্ত শূন্য হয় তবে স্কেলিং এবং / অথবা পয়েন্টগুলির সেট ঘোরানো কেন্দ্রীয় মুহুর্তকে শূন্যের সমান রাখবে।
তৃতীয়, আসুন প্রথম দুটি পয়েন্ট স্থির করা হয়েছে এমন পয়েন্টগুলির তালিকার মানদণ্ডটি প্রমাণ করা যাক:
```
P = {0, 1, x[3] + I*y[3], x[4] + I*y[4]};
```
দ্বিতীয় এবং তৃতীয় কেন্দ্রীয় মুহুর্তের আসল এবং কল্পিত অংশগুলি কোন পরিস্থিতিতে শূন্য?
```
C2 = CentralMoment[P, 2] // ReIm // ComplexExpand // FullSimplify;
C3 = CentralMoment[P, 3] // ReIm // ComplexExpand // FullSimplify;
Solve[Thread[Join[C2, C3] == 0], {x[3], y[3], x[4], y[4]}, Reals] // FullSimplify
(*    {{x[3] -> 0, y[3] -> -1, x[4] -> 1, y[4] -> -1},
       {x[3] -> 0, y[3] -> 1, x[4] -> 1, y[4] -> 1},
       {x[3] -> 1/2, y[3] -> -1/2, x[4] -> 1/2, y[4] -> 1/2},
       {x[3] -> 1/2, y[3] -> 1/2, x[4] -> 1/2, y[4] -> -1/2},
       {x[3] -> 1, y[3] -> -1, x[4] -> 0, y[4] -> -1},
       {x[3] -> 1, y[3] -> 1, x[4] -> 0, y[4] -> 1}}    *)
```
এই ছয়টি সমাধানের সমস্তই বর্গক্ষেত্রকে উপস্থাপন করে: সুতরাং, একমাত্র উপায় যা ফর্মের পয়েন্টগুলির একটি তালিকা{0, 1, x[3] + I*y[3], x[4] + I*y[4]} শূন্য দ্বিতীয় এবং তৃতীয় কেন্দ্রীয় মুহুর্ত থাকতে পারে কেবল যখন চারটি পয়েন্ট একটি বর্গ গঠন করে।

অনুবাদ এবং ঘূর্ণন, এবং স্কেলিং বৈশিষ্ট্যগুলি 1 এবং 2 পয়েন্টগুলিতে প্রদর্শিত হয়েছে এর অর্থ এই যে যে কোনও সময় দ্বিতীয় এবং তৃতীয় কেন্দ্রীয় মুহূর্তগুলি শূন্য হয়, আমাদের কিছু অনুবাদ / ঘূর্ণন / স্কেলিং অবস্থায় একটি বর্গ রয়েছে have ∎

সাধারণীকরণ

নিয়মিত এন-গনের কে-থের কেন্দ্রীয় মুহূর্তটি শূন্য হয় যদি কে এন দিয়ে বিভাজ্য না হয়। এন-গনস সনাক্ত করার জন্য পর্যাপ্ত মানদণ্ড তৈরি করতে এই শর্তগুলির যথেষ্ট পরিমাণে একত্রিত করতে হবে। N = 4 কেসের ক্ষেত্রে কে = 2 এবং কে = 3 এ জিরো সনাক্ত করা যথেষ্ট ছিল; শনাক্তকরণের জন্য, উদাহরণস্বরূপ, হেক্সাগন (n = 6) জিরোগুলির জন্য কে = 2,3,4,5 পরীক্ষা করা প্রয়োজন হতে পারে। আমি নিম্নলিখিতগুলি প্রমাণ করে দেখিনি, তবে সন্দেহ করে যে এটি কোনও নিয়মিত এন-গন সনাক্ত করবে:

isregularngon[p_List] :=
  And @@ Table[PossibleZeroQ[CentralMoment[p, k]], {k, 2, Length[p] - 1}]

কোড চ্যালেঞ্জটি মূলত দৈর্ঘ্য -4 তালিকার জন্য এই কোড বিশেষ।

— রোমান
সূত্র

সমাধানটি মোটামুটি আকর্ষণীয় দেখায়। আপনি কেন ব্যাখ্যা করতে পারেন কেন এটি সঠিক উত্তর দেয়?

— জোয়েল

@ জোয়েল আমি একটি প্রমাণ যুক্ত করেছি

— রোমান

অনেক ধন্যবাদ. এটি আদর্শ হবে যে এই সুন্দর সমাধানটির আরও স্বজ্ঞাত গাণিতিক ব্যাখ্যা থাকতে পারে।

— জোয়েল

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

— রোমান

গ্রেট। এই সমাধানের পথ দেখানোর জন্য ধন্যবাদ।

— জোয়েল

0

জে, ^{31 29 27} 26

3=[:#[:~.[:,([:+/*:@-)"1/~

~~পয়েন্টগুলির মধ্যে 8 টি সবচেয়ে ছোট দূরত্ব একই কিনা তা পরীক্ষা করে দেখুন।~~ পয়েন্টগুলির মধ্যে ঠিক তিন ধরণের দূরত্ব রয়েছে কিনা তা পরীক্ষা করে (শূন্য, পাশের দৈর্ঘ্য এবং তির্যক দৈর্ঘ্য)।

f 4 2 $ 0 0 2 1 3 _1 1 _2
1
f 4 2 $ 0 0 0 2 3 2 3 0
0

4 2 $ জেতে একটি অ্যারে লেখার উপায় is

— Eelvex
সূত্র

এটি রম্বস পরীক্ষায় ব্যর্থ হয়।

— জেবি

@ জেবি: আমার একটি টাইপ ছিল। আমি এখন যাইহোক পদ্ধতি পরিবর্তন।

— এলেভেক্স

নতুন ... আপনি যে পদ্ধতিটি চুরি করছিলেন আপনি একই পদ্ধতি গ্রহণ করছেন। আমার সংস্করণ সংক্ষিপ্ত বাদে: পি

— জেবি

@ জেবি: সত্যি? আমি তা খেয়াল করিনি। আর কে চেক করে (3 == # দূরত্বে)?

— এলেভেক্স

@ জেবি: ও ... ... 2 এর সংমিশ্রনের জন্য কিছু পরীক্ষা করুন: - /

— ইয়েলেক্স

0

106 টি অক্ষরের জন্য স্মার্টটাক

s:=Set new.
p permutationsDo:[:e|s add:((e first - e second) dotProduct:(e first - e third))].
s size = 2

যেখানে p হ'ল পয়েন্টের সংগ্রহ, যেমন

p := { 0@0. 2@1. 3@ -1. 1@ -2}. "twisted square"

আমি মনে করি গণিতটি বেশ শক্ত ...

2 টি পৃথক ডট পণ্য যাচাই করা এটি কাটবে না। একই অবস্থানে রাখা পয়েন্টগুলি মিথ্যা ধনাত্মকতা তৈরি করতে পারে।

— আআআআআআআআআআআআআআআআআআআআআআআআআআআআ

0

গণিত, 123 টি অক্ষর (তবে আপনি আরও ভাল করতে পারেন):

Flatten[Table[x-y,{x,a},{y,a}],1]
Sort[DeleteDuplicates[Abs[Flatten[Table[c.d,{c,%},{d,%}]]]]]
%[[1]]==0&&%[[3]]/%[[2]]==2

যেখানে 'ক' ম্যাথমেটিকা তালিকা ফর্মের ইনপুট, যেমন: a={{0,0},{3,4},{8,4},{5,0}}

মূলটি হ'ল সমস্ত ভেক্টরের মধ্যে ডট পণ্যগুলি লক্ষ্য করা এবং লক্ষ্য করুন যে তাদের অবশ্যই তিনটি মান থাকতে হবে: 0, x এবং 2 * x এর কিছু মূল্যের জন্য x। বিন্দুর পণ্যটি একটি ফোলা ফোড়ায় দৈর্ঘ্য এবং দৈর্ঘ্য উভয়ই পরীক্ষা করে।

আমি জানি ম্যাথমেটিকা শর্টকাট রয়েছে যা এটি আরও খাটো করে তুলতে পারে তবে তারা কী তা আমি জানি না।

— barrycarter
সূত্র

আমি মনে করি এটিও ভুল, তবে কোডটি কী করে তা আমি অনুভব করতে পারি না।

— আআআআআআআআআআআআআআআআআআআআআআআআআআআআ

এটি 4 টি পয়েন্টের মধ্যে সমস্ত ভেক্টর গণনা করে, ডট পণ্যগুলির সমস্ত (নিখুঁত মান) নেয় এবং এক্স এর কিছু মূল্যের জন্য ফলাফল 0, x, 2 * x এর সাথে মিলিত হওয়ার প্রত্যাশা করে।

— ব্যারিকার্টার

সুতরাং 16 ভেক্টর -> 256 ডট পণ্য এবং আপনি যাচাই করে দেখেন যে উচ্চ মানটি 2 গুণ কম, তবে প্রতিটি মানের কতটি আছে তা আপনি পান না। এটা কি সঠিক বোঝা গেল?

— আআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআ

হ্যাঁ, এটি আমার অ্যালগরিদমকে সঠিকভাবে বর্ণনা করে। এবং আমি এখন মনে করি আপনি ঠিক বলেছেন: আপনি এমন একটি দৃশ্য নির্মাণ করতে পারেন যেখানে সমস্ত 3 টি মান দেখা গিয়েছিল, তবে সঠিক পরিমাণে নয়। ইঁদুর। যদিও ঠিক করা উচিত?

— ব্যারিকার্টার

@ বাররিকার্টার আপনি Unionপরিবর্তে ব্যবহার করে অক্ষর সংরক্ষণ করতে পারেন Sort@DeleteDuplicates। আমি আপনার 3 টি লাইন একসাথে

#[[1]] == 0 && #[[3]]/#[[2]] == 2 &[  Union@Abs@Flatten[Table[c.d, {c, #}, {d, #}]] &[   Flatten[Table[x - y, {x, a}, {y, a}], 1]]]

— রেখেছি

0

হাস্কেল, "wc -c" 110 টি চরিত্রের প্রতিবেদন করেছে। ইনপুটটিতে 4 টি উপাদান রয়েছে কিনা তা পরীক্ষা করে না।

import Data.List
k [a,b]=2*a==b
k _=0<1
h ((a,b):t)=map (\(c,d)->(a-c)^2+(b-d)^2) t++h t
h _=[]
j=k.nub.sort.h

আমি পরীক্ষা করেছিলাম

test1 = [(0,0),(3,4),(-4,3),(-1,7)] -- j test1 is True
test2 = [(0,0),(3,4),(-3,4),(0,8)]  -- j test2 is False

— ক্রিস কুকলিউইচস
সূত্র

নোট করুন উপরেরটি কখনই একটি বিন্দু থেকে নিজের দিকে দূরত্ব পায় না, সুতরাং 0 এর দূরত্বের উপস্থিতি ইনপুট তালিকার একটি পুনরাবৃত্তি বিন্দু নির্দেশ করবে এবং এটি কে [0, খ] হিসাবে সাজানো তালিকায় প্রদর্শিত হবে সুতরাং 2 * 0 == খ সর্বদা ব্যর্থ হবে যেহেতু খ 0 এর সমান হতে পারে না

— ক্রিস কুকলিউইচ

4 টি পয়েন্ট একটি বর্গ গঠন করে কিনা তা নির্ধারণ করুন

পাইথন 176 90 79 বাইট

জে, 28 17 25 27

পাইথন, 71 42

হাস্কেল, 100 টি অক্ষর

গুণক

পাইথন (105)

পাইথন - 42 টি অক্ষর

কে - 33

OCaml + ব্যাটারি, 132 টি অক্ষর

গণিত 65 65 69 66

জেলি , 8 বাইট

হাস্কেল (212)

স্কালা (১৪6 টি অক্ষর)

জাভাস্ক্রিপ্ট ১৪৪ টি অক্ষর

পিএইচপি, 161 158 টি অক্ষর

জাভাস্ক্রিপ্ট 1.8, 112 টি অক্ষর

GoRuby - 66 টি অক্ষর

সি #, 107 টি অক্ষর

পাইথন, 66

পাইথন 2 , 49 বাইট

ওল্ফ্রাম ভাষা (গণিত) , 32 31 বাইট

প্রমাণ

সাধারণীকরণ

জে, 31 29 27 26

106 টি অক্ষরের জন্য স্মার্টটাক

গণিত, 123 টি অক্ষর (তবে আপনি আরও ভাল করতে পারেন):

জে, ^{31 29 27} 26