आयतों में आयतें
इस कोड गोल्फ चुनौती आप दो धनात्मक पूर्णांक दे देंगे nऔर kइनपुट के रूप में और आप पूर्णांक निर्देशांक के साथ आयतों के चारों तरफ छू कोने के साथ तैयार किया जा सकता की संख्या की गिनती है \$n \times k\$ आयत $$ \{(x,y) : 0 \leq x \leq n, 0 \leq y \leq k\}. $$ यही है, वहाँ होना चाहिए:
- कम से कम एक शीर्ष के साथ एक \$x\$-कॉर्डिनेट ऑफ़ \ _$0\$,
- कम से कम एक शीर्ष के साथ एक \$x\$-कॉर्डिनेट ऑफ़ \ _$n\$,
- कम से कम एक शीर्ष के साथ एक \$y\$-कॉर्डिनेट ऑफ़ \ _$0\$, तथा
- कम से कम एक शीर्ष के साथ एक \$y\$-कॉर्डिनेट ऑफ़ \ _$k\$।
उदाहरण
वहाँ हैं \$a(5,7) = 5\$पूर्णांक के साथ आयतें एक \ के सभी चार पक्षों को छूती हैं$5 \times 7\$ आयत:
टेबल
की (सममित) तालिका के निचले त्रिकोण \$a(n,k)\$के लिए \$n,k \leq 12\$ है
n\k| 1 2 3 4 5 6 7 8 9 10 11 12
---+----------------------------------------------
1 | 1 . . . . . . . . . . .
2 | 1 2 . . . . . . . . . .
3 | 1 1 5 . . . . . . . . .
4 | 1 1 1 6 . . . . . . . .
5 | 1 1 1 3 9 . . . . . . .
6 | 1 1 1 1 1 10 . . . . . .
7 | 1 1 1 1 5 1 13 . . . . .
8 | 1 1 1 1 1 1 5 14 . . . .
9 | 1 1 1 1 1 5 1 1 17 . . .
10 | 1 1 1 1 1 3 1 3 1 18 . .
11 | 1 1 1 1 1 1 5 1 5 5 21 .
12 | 1 1 1 1 1 1 1 1 5 1 1 22
यह एक कोड-गोल्फ चुनौती है, इसलिए सबसे छोटा कोड जीतता है।
जवाब
05AB1E , 10 8 बाइट्स
LDI-*`¢O
इसे ऑनलाइन आज़माएं!
टिप्पणी की :
# implicit input: [n, k]
L # for both values take the [1..x] range
# [[1,...,n], [1,...,k]]
D # duplicate this list
I # push the input [n,k]
- # subtract this from the ranges
# [[1-n,...,n-n], [1-k,...,k-k]]
# =[[-n+1,...,0], [-k+1,...,0]]
* # multiply with the ranges
# [[1*(-n+1),...,n*0], [1*(-k+1),...,k*0]]
` # push all lists of this list on the stack
¢ # count the occurences of each value of one list in the other
O # sum those counts
पायथन 2 , 66 59 बाइट्स
lambda n,k:sum(a%n*(n-a%n)==a/n*(k-a/n)for a in range(n*k))
इसे ऑनलाइन आज़माएं!
प्रत्येक संभव आयत के अंदर \$n \times k\$-दंगे को दो पूर्णांकों द्वारा निर्दिष्ट किया जा सकता है, \$0 \le a \lt n\$और \$0 \le b \lt k\$:
एक आयत दी सत्यापित करने के लिए \$a\$और \$b\$, यह जांचने के लिए पर्याप्त है कि क्या एक कोण एक सही कोण है। ऐसा करने के लिए मैं \ के डॉट उत्पाद लेता हूं$\binom{b}{0}-\binom{0}{a}=\binom{-b}{a}\$और \$\binom{k-b}{n}-\binom{0}{a}=\binom{k-b}{n-a}\$यह देखने के लिए कि क्या कोण \ _ पर है$\binom{0}{a}\$ एक समकोण है:
$$ \langle \left( \begin{matrix} -b \\ a \\ \end{matrix}\right), \left(\begin{matrix} k-b \\ n-a \\ \end{matrix} \right) \rangle = 0 \\\Leftrightarrow a\cdot(n-a)-b\cdot(k-b)=0 \\\Leftrightarrow a\cdot(n-a)=b\cdot(k-b) $$
सी (जीसीसी) , 63 61 बाइट्स
सेविंग के लिए 2 धन्यवाद !!!
s;a;f(n,k){for(s=a=n*k;a--;)s-=a%n*(n-a%n)!=a/n*(k-a/n);a=s;}
इसे ऑनलाइन आज़माएं!
पोर्ट ऑफ OVS के अजगर जवाब ।
स्काला , 65 64 60 51 बाइट्स
n=>k=>0 to n*k-1 count(a=>a%n*(n-a%n)==a/n*(k-a/n))
इसे ऑनलाइन आज़माएं!
- -1 उपयोगकर्ता के लिए धन्यवाद !
- -4 ओव्स के लिए धन्यवाद !
- -9 Kjetil के लिए धन्यवाद !
चारकोल , 21 बाइट्स
ＮθＮηＩΣＥθ№Ｅη×λ⁻ηλ×ι⁻θι
इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण: गणना \$ x(n-x) \$के लिए \$ 0 \le x < n \$और \$ y(n-y) \$के लिए \$ 0 \le y < k \$और दोनों सूचियों में एक पूर्णांक दिखाई देने वाले समय की संख्या को गिना जाता है, जो निर्देशांक \ के साथ समांतरभुज से मेल खाती है$ (x, 0), (0, y), (n - x, 0), (0, k - y) \$ 90 डिग्री कोण वाले:
ＮθＮη
इनपुट \$ n \$और \$ k \$।
ＩΣ
सभी मैचों के कुल योग का आउटपुट मिला।
Ｅη×λ⁻ηλ
गणना \$ y(n-y) \$के लिए \$ 0 \le y < k \$।
Ｅθ№...×ι⁻θι
गणना \$ x(n-x) \$के लिए \$ 0 \le x < n \$ और गिनें कि प्रत्येक पूर्णांक दूसरी सूची में कितनी बार दिखाई देता है।
जावास्क्रिप्ट (ईएस 6), 63 58 56 बाइट्स
@ ब्वॉयज के लिए 2 बाइट्स को सहेजा गया
(n,y=x=0)=>g=k=>(x=x||++y*k--&&n)&&(y*k==--x*(n-x))+g(k)
इसे ऑनलाइन आज़माएं!
रेटिना , 45 बाइट्स
\d+
*
L$w`(_+) (_+) $.`*$1=$.2*$' m`^(.*)=\1$
इसे ऑनलाइन आज़माएं! लिंक में परीक्षण सूट शामिल है। अंतरिक्ष-पृथक इनपुट लेता है। स्पष्टीकरण:
\d+
*
इनपुट्स को यूनीरी में बदलें।
L$w`(_+) (_+)
सभी सबस्ट्रिंग का मिलान करें _ _। यह \ $ 0 \ le x <n \ $ और \ $ 0 \ le y <k \ $ के सभी जोड़े से मेल खाता है जो स्ट्रिंग के आरंभ और अंत में बेजोड़ भागों द्वारा दर्शाए गए हैं $`और $'क्रमशः \ n n - x हैं \ $ और \ $ k - y \ $ क्रमशः $1और द्वारा प्रतिनिधित्व किया $2जाता है।
$.`*$1=$.2*$'
प्रत्येक जोड़ी के लिए, (unary) उत्पादों की सूची \ $ x (n - x) \ $ और \ $ y (k - y) \ $ ।
m`^(.*)=\1$
समय की गिनती करें कि वे समान हैं।
जेली , 8 बाइट्स
r1×ḶċⱮ/S
एक मोनडिक लिंक जो पूर्णांकों की एक जोड़ी को स्वीकार करता है जो गणना करता है।
इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें ।
कैसे?
r1×ḶċⱮ/S - Link [n,k]
r1 - ([n,k]) inclusive range to 1 = [[n,n-1,...,1],[k,k-1,...,1]]
Ḷ - lowered range ([n,k]) = [[0,1,...,n-1],[0,1,...,k-1]]
× - multiply = [[n×0,(n-1)×1,...,1×(n-1)],[k×0,(k-1)×1,...,1×(k-1)]]
/ - reduce by - i.e.: f(A=[n×0,(n-1)×1,...,1×(n-1)], B=[k×0,(k-1)×1,...,1×(k-1)])
Ɱ - map with - i.e.: [f(A,v) for v in B]
ċ - count occurrenes (of v in A)
S - sum
हास्केल , 53 47 बाइट्स
a#b=sum[1|x<-[1..a],y<-[1..b],x*(a-x)==y*(b-y)]
इसे ऑनलाइन आज़माएं!
- @Ovs के लिए 6 धन्यवाद सहेजे गए
हम उस अभिव्यक्ति का उपयोग करते हैं x/(b-y)==y/(a-x)जिसे x*(a-x)==y*(b-y)मोडुलो चेक से बचने के लिए परिवर्तित किया गया है।
अभिव्यक्ति पक्षों (दूसरे उल्टे) के बीच के अनुपात की गणना करती है जिसे एक मान्य आयत होने के लिए समान होना चाहिए।
पर्ल 5 , ( -p -Minteger) 54 बाइट्स
/ /;$_=grep$_%$'*($'-$_%$')==$_/$'*($`-$_/$'),1..$`*$'
इसे ऑनलाइन आज़माएं! एक ही सूत्र का उपयोग करना, और रेंज उत्पाद को अंडाकार के रूप में छोड़कर सीमा 1 से शुरू होती है
जावा 8, 75 बाइट्स
n->k->{int r=0,a=n*k;for(;a-->0;)if(a%n*(n-a%n)==a/n*(k-a/n))r++;return r;}
पोर्ट ऑफ @ovs 'पायथन 2 का जवाब है , इसलिए उसे उभारना सुनिश्चित करें!
इसे ऑनलाइन आज़माएं।
फोर्थ (gforth) , 72 बाइट्स
: f 0e over 0 do dup 0 do
2dup i - i * swap j - j * = s>f f- loop loop ;
इसे ऑनलाइन आज़माएं!
फिर भी ओव्स पायथन 2 उत्तर का एक और पोर्ट , सिवाय इसके कि यह नेस्टेड छोरों का उपयोग करता है। कई प्रतियों की आवश्यकता होने पर डायरेक्ट लूप काउंटर बहुत सस्ता होता है।
n kमुख्य स्टैक से लेता है और एफपी स्टैक के माध्यम से गिनती लौटाता है।
: f ( n k -- f:cnt )
0e \ setup the initial count
over 0 do \ outer loop (j): 0 to n-1
dup 0 do \ inner loop (i): 0 to k-1
2dup \ ( n k n k )
i - i * swap \ ( n k i*[k-i] n )
j - j * = \ ( n k i*[k-i]==j*[n-j] ) Forth boolean is 0/-1
s>f f- \ increment count if equal
loop
loop
;