परिचय

खेल के मैदान के इस दृश्य को देखते हुए:

(0,0)
+----------------------+(map_width, 0)
|           A          |
|-----+-----------+----|
|  D  |     W     | B  |
|-----+-----------+----|
|           C          |
+----------------------+(map_width, map_height)
(0, map_height)

पूरा खेल जिस पर खेला जाता है वह कोने निर्देशांक (0,0) और (map_width, map_height) के साथ आयत है। शत्रु को मारने के लिए पात्र संघ

एस = ⋃ (ए, बी, सी, डी)

$S = \bigcup (A, B, C, D)$

चुनौती

वह कोड लिखें जो एक यादृच्छिक बिंदु लौटाता है (x, y) जो कि एस के अंदर होने की गारंटी है। आपका कोड किसी भी अतिरिक्त पूर्वाग्रह का परिचय नहीं दे सकता है, जिसका अर्थ है कि प्रत्येक समन्वय की संभावना को समान रूप से इस धारणा को वितरित किया जाता है कि यादृच्छिकता उत्पन्न करने की आपकी पसंद (जैसे फ़ंक्शन | पुस्तकालय | देव / उर्जित) निष्पक्ष है।

बाइट्स जीत में सबसे कम समाधान!

इनपुट

आप क्रम में 6 सकारात्मक पूर्णांक इनपुट चर की कुल दिया जाएगा: map_width, map_height, W_top_left_x, W_top_left_y, W_width, W_height। आप मान सकते हैं कि सभी क्षेत्रों (ए, बी, सी, डी, डब्ल्यू) की सतह (गणना) सतह प्रत्येक> 10 है, इसलिए कोई खाली स्थान / क्षेत्र नहीं हैं।

उदाहरण इनपुट: 1000, 1000, 100, 100, 600, 400

Te इनपुट में ऊपर वर्णित 6 मान समाहित हैं लेकिन इसे कम संख्या में तर्कों और किसी भी क्रम में पारित किया जा सकता है। उदाहरण के लिए (map_width, map_height)अजगर टपल के रूप में गुजरने की अनुमति है। कोर्स की अनुमति नहीं है, डब्ल्यू के नीचे सही बिंदु की तरह गणना पैरामीटर हैं।

उत्पादन

2 बेतरतीब ढंग से उत्पन्न पूर्णांक (x, y) जहां

(0 \leq एक्स < map_width) \land \neg (W_top_left_x \leq एक्स < W_top_left_x + view_width)

$(0 \leq x \lt \text{map_width}) \land \neg (\text{W_top_left_x} \leq x \lt \text{W_top_left_x} + \text{view_width})$

या

(0 \leq y < map_height) \land \neg (W_top_left_y \leq y < W_top_left_y + view_height)

$(0 \leq y \lt \text{map_height}) \land \neg (\text{W_top_left_y} \leq y \lt \text{W_top_left_y} + \text{view_height})$

उपरोक्त तार्किक अभिव्यक्तियों में से कम से कम एक को सत्य होना चाहिए।

उदाहरण

Input                                    Output(valid random samples)

1000 1000 100 100 600 400                10 10
1000 1000 100 100 600 400                800 550
1000 1000 100 100 600 400                800 10
1000 1000 100 100 600 400                10 550

इनपुट / आउटपुट के विवरण और सीमाओं के लिए कृपया डिफ़ॉल्ट इनपुट / आउटपुट नियमों को देखें

code-golf random game

— jaaq
स्रोत

मुझे लगता है कि आपको स्पष्ट रूप से बताना चाहिए कि आउटपुट निर्देशांक पूर्णांक हैं (जो मैं आपके निहित इरादे के रूप में अनुमान लगाता हूं)।

— agtoever

1

क्या हम डिफ़ॉल्ट इनपुट / आउटपुट नियमों का उपयोग कर सकते हैं ?

— निक कैनेडी

1

@ यह "आउटपुट" अनुभाग में ऐसा कहता है; 2 randomly generated integers (x, y)

— ग्यूसेप

1

क्या हम एक अलग (सुसंगत) क्रम में इनपुट ले सकते हैं?

— अटिनाट

@agtoever हाँ आउटपुट को "आउटपुट" खंड में बताया गया एक पूर्णांक होना चाहिए।

— jaq

7

पायथन 2 , 114 106 102 101 बाइट्स

lambda w,h,X,Y,W,H:choice([(i%w,i/w)for i in range(w*h)if(W>i%w-X>-1<i/w-Y<H)<1])
from random import*

इसे ऑनलाइन आज़माएं!

— TFeld
स्रोत

मुझे यकीन नहीं है लेकिन मुझे लगता है कि यह होना चाहिए [i%w, i/w] क्योंकि रेंज w*h/w=hलेकिन x इस उदाहरण में चौड़ाई से बंधा हुआ है ऊंचाई नहीं।

— jaq

@ अंजाम हाँ, तुम सही हो। अब ठीक है, धन्यवाद :)

— TFeld

मैंने अभी आपके द्वारा बनाई गई सूची की सामग्री की जाँच की और ऐसा लगता है कि आपका समाधान गलत है। बिंदुओं को प्लॉट करने से पता चलता है कि सभी मान एक रेखा के साथ हैं और एस के पूरे क्षेत्र को इरादा के अनुसार नहीं भरते हैं। इसके अलावा, आपके द्वारा बनाई गई सूची में गैर-पूर्णांक मान शामिल हैं।

— jaq

@jaaq मुझे यकीन नहीं है कि आपका क्या मतलब है? निर्देशांक हमेशा पूर्णांक होते हैं, और एक पंक्ति पर नहीं होते हैं ( उदाहरण के लिए )

— TFeld

1

@jaaq पायथन 2 में, a/bपहले से ही फर्श विभाजन है, अगर aऔर bपूर्णांक हैं (जो वे यहां हैं)।

— TFeld

4

आर , 89 73 बाइट्स

function(w,h,K,D,`*`=sample){while(all((o<-c(0:w*1,0:h*1))<=K+D&o>K))0
o}

इसे ऑनलाइन आज़माएं!

के रूप में इनपुट लेता है width,height,c(X,Y),c(W,H)।

$[0,w]\times[0,h]$

— ग्यूसेप
स्रोत

4

05AB1E , 23 21 20 18 17 बाइट्स

L`â<ʒ²³+‹y²@«P≠}Ω

इनपुट प्रारूप में है [map_width, map_height], [W_top_left_x, W_top_left_y], [W_width, W_height]।

-1 बाइट के लिए @Grimy का धन्यवाद , और मुझे यह अहसास कराने के लिए कि मैंने अपने लेटेस्ट एडिट के बाद बग की शुरुआत की है।

इसे ऑनलाइन आज़माएं , एक ही समय में 10 संभावित आउटपुट या सभी संभव निर्देशांक सत्यापित करें । (माइनर नोट: मैंने उदाहरण इनपुट को एक कारक 10 से घटा दिया है, क्योंकि फ़िल्टर और रैंडम विकल्प बिलिन एरे बड़ी सूचियों के लिए बहुत धीमा है।)

स्पष्टीकरण:

इनपुट के map_width, map_height, [W_top_left_x, W_top_left_y], [W_width, W_height]रूप में जाना जाता है[Wm, Hm], [x, y], [w, h] नीचे:

L          # Convert the values of the first (implicit) input to an inner list in
           # the range [1, n]: [[1,2,3,...,Wm],[1,2,3,....,Hm]]
 `         # Push both inner lists separated to the stack
  â        # Get the cartesian product of both lists, creating each possible pair
   <       # Decrease each pair by 1 to make it 0-based
           # (We now have: [[0,0],[0,1],[0,2],...,[Wm,Hm-2],[Wm,Hm-1],[Wm,Hm]])
    ʒ      # Filter this list of coordinates [Xr, Yr] by:
     ²³+   #  Add the next two inputs together: [x+w, y+h]
        ‹  #  Check for both that they're lower than the coordinate: [Xr<x+w, Yr<y+h]
     y     #  Push the coordinate again: [Xr, Yr]
      ²    #  Push the second input again: [x, y]
       @   #  Check for both that the coordinate is larger than or equal to this given 
           #  input: [Xr>=x, Yr>=y] (the w,h in the input are ignored)
     «     #  Merge it with the checks we did earlier: [Xr<x+w, Yr<y+h, Xr>=x, Yr>=y]
      P≠   #  And check if any of the four is falsey (by taking the product and !=1,
           #  or alternatively `ß_`: minimum == 0)
    }Ω     # After the filter: pick a random coordinate
           # (which is output implicitly as result)

— केविन क्रूज़सेन
स्रोत

1

सत्यापित भाग :) महान समाधान जोड़ने के लिए धन्यवाद!

— jaq

1

@ अंजाम धन्यवाद! मैंने अपने शुरुआती संस्करण के बाद स्वयं सत्यापनकर्ता का उपयोग किया है, जो कि जब मैंने देखा कि मुझे बग को ठीक करना है, क्योंकि यह [map_height, 0]बिना यादृच्छिक यादृच्छिक समन्वयन के साथ शामिल था ¨। :)

— केविन क्रूज़सेन

*Ý¨¹‰के L`â<रूप में पहले दो इनपुट लेने के द्वारा किया जा सकता है [map_height, map_width]। यह भी IIहो सकता है Š, जब तक कि मुझे कुछ याद न हो।

— ग्रैमी

@Grimy के लिए धन्यवाद L`â<। के रूप में II+करने के लिए Š+, आप वास्तव में अपने आप कर रहे हैं सही है कि यह ही होगा .. दुर्भाग्य से मैं भूल हो गई है और यह किया जाना चाहिए था ²³+के बजाय II+, क्योंकि यह दोनों के लिए तीसरे इनपुट का प्रयोग करेंगे I(जैसे यह दो बार ले जाएगा Šफिल्टर के पहले पुनरावृत्ति के बाद) के साथ तीसरा इनपुट .. तो मुझे एक बग था मुझे एहसास कराने के लिए संक्षेप में धन्यवाद। :)

— केविन क्रूज़सेन

3

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 110 बाइट्स

(a,b,c,d,e,f)=>{int g=c,h=d;for(var z=new Random();g>=c&g<e+c|h>=d&h<f+d;h=z.Next(b))g=z.Next(a);return(g,h);}

इसे ऑनलाइन आज़माएं!

— अज्ञान का अवतार
स्रोत

3

पॉवरशेल , 85 73 बाइट्स

^{-12 बाइट्स mazzy के लिए धन्यवाद}

param($a,$b,$x,$y,$w,$h)$a,$b|%{0..--$x+($x+$w+2)..$_|random
$x,$w=$y,$h}

इसे ऑनलाइन आज़माएं!

अच्छा सरल उत्तर जो प्रत्येक आयाम के लिए मूल्यों की श्रेणी से बना एक सरणी को एक साथ सिलता है और फिर एक यादृच्छिक रूप से चुनता है xऔर y। पहले प्रसंस्करण द्वारा अधिकांश कोड का पुन: उपयोग करने का प्रबंधन करता है x, फिर इसके $xसाथ ओवरराइटिंग $yऔर इसे फिर से चलाता है।

— Veskah
स्रोत

1

आप कुछ बाइट्स बचा सकते हैं इसे ऑनलाइन आज़माएं!

— मेज़ी

1

@mazzy मैंने वास्तव में रेंज ऑप्टिमाइज़ेशन में ठोकर खाई थी लेकिन 0 बाइट्स बचाते हुए इसे पीछे की तरफ लगाया।

— विस्कह

1

जूलिया , 76 71 67 बाइट्स

f(w,h,a,b,c,d)=rand(setdiff((0:w-1)'.=>0:h-1,(a:a+c-1)'.=>b:b+d-1))

इसे ऑनलाइन आज़माएं!

— user3263164
स्रोत

1

जेली , 11 बाइट्स

p/’$€+2¦ḟ/X

इसे ऑनलाइन आज़माएं!

एक डाईएडिक लिंक जो दो तर्क लेता है, [map_width, map_height], [W_width, W_height]और W_left, W_topआवश्यकताओं को पूरा करते हुए एक यादृच्छिक रूप से चयनित बिंदु देता है।

व्याख्या

   $€       | For each of member of the left argument, do the following as a monad:
p/          | - Reduce using Cartesian product (will generate [1,1],[1,2],... up to the width and height of each of the rectangles)
  ’         | - Decrease by 1 (because we want zero-indexing)
     +2¦    | Add the right argument to the second element of the resulting list
        ḟ/  | Reduce by filtering members of the second list from the first
          X | Select a random element

— निक केनेडी
स्रोत

1

अजगर 2 , 100 बाइट्स

इनपुट के रूप में होना चाहिए ((map_width, W_top_left_x, W_width),(map_height, W_top_left_y, W_height))

आउटपुट फॉर्म में दिया गया है: [[x],[y]]

lambda C:[c(s(r(i[0]))-s(r(i[1],i[1]+i[2])),1)for i in C]
from random import*;c=sample;r=range;s=set

इसे ऑनलाइन आज़माएं!

उदाहरण इनपुट से प्राप्त रैंडम आउटपुट:

[[72], [940]]
[[45], [591]]
[[59], [795]]
[[860], [856]]
[[830], [770]]
[[829], [790]]
[[995], [922]]
[[23], [943]]
[[761], [874]]
[[816], [923]]

— Ioannes
स्रोत

1

जावा (ओपनजेडके 8) , 100 बाइट्स

W->H->r->{int x=0,y=0;for(;r.contains(x+=W*Math.random(),y+=H*Math.random());x=y=0);return x+","+y;}

इसे ऑनलाइन आज़माएं!

java.awt.Rectangleकुछ मापदंडों के धारक के रूप में उपयोग करता है । स्वाभाविक रूप से, वे intखेतों का उपयोग करते हैं, floatया नहीं double।

— ओलिवियर ग्रेजायर
स्रोत

1

ओह, Rectangle#containsबिलिन के साथ सचमुच चुनौती लेने का अच्छा तरीका ! : डी

— केविन क्रूज़सेन 17

1

वोल्फ्राम भाषा (गणितज्ञ) , 84 68 60 बाइट्स

RandomChoice[g=Join@@List~Array~##&;#~g~0~Complement~g@##2]&

इसे ऑनलाइन आज़माएं!

इनपुट के रूप में ले लो {map_width, map_height}, {W_width, W_height}, {W_top_left_x, W_top_left_y}।

— attinat
स्रोत

0

चारकोल , 55 43 बाइट्स

ＮθＮηＦＥ²Ｎ⊞υ⟦ιＮ⟧Ｉ‽ΦＥ×θη⟦﹪ιθ÷ιθ⟧⊙υ∨‹§ιμ§λ⁰¬‹§ιμΣλ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

ＮθＮη

नक्शा आकार इनपुट करें। (यदि वे अंतिम थे, तो मैं 1-बाइट बचत के लिए ऊंचाई इनलाइन इनपुट कर सकता था।)

ＦＥ²Ｎ⊞υ⟦ιＮ⟧

आंतरिक आयत इनपुट करें। (यदि मैं ऑर्डर में इनपुट कर सकता हूं left, width, top, heightतो मैं Ｆ²⊞υＥ²Ｎ3-बाइट की बचत के लिए उपयोग कर सकता हूं ।)

Ｅ×θη⟦﹪ιθ÷ιθ⟧

क्षेत्र में सभी समन्वयकों की सूची तैयार करें।

Φ...⊙υ∨‹§ιμ§λ⁰¬‹§ιμΣλ

ऐसी प्रविष्टियाँ फ़िल्टर करें जहाँ दोनों को-ऑर्डिनेट्स आयत के अंदर स्थित हों।

Ｉ‽...

जो बचे हैं उनका एक यादृच्छिक तत्व प्रिंट करें।

— नील
स्रोत

0

पर्ल 5 `-ap` , 84 बाइट्स

sub c{($c=0|rand((pop)+($l=pop)-"@_"))<$l?$c:$c+"@_"-$l}say c@F[4,2,0];$_=c@F[5,3,1]

इसे ऑनलाइन आज़माएं!

— Xcali
स्रोत

0

स्काला , 172 बाइट्स

अनियमितता? पकड़ लिया।

(a:Int,b:Int,c:Int,d:Int,e:Int,f:Int)=>{var r=new scala.util.Random
var z=(0,0)
do{z=(r.nextInt(a),r.nextInt(b))}while((c to e+c contains z._1)|(d to e+d contains z._2))
z}

एक मजेदार क्रियान्वयन जिसके बारे में मैं सोच सकता था।
यह कैसे काम करता है : नक्शे में एक यादृच्छिक जोड़ी उत्पन्न करें। यदि यह आंतरिक आयत में है, तो पुन: प्रयास करें।
इसे ऑनलाइन आज़माएं!

— वी। कोर्टीस
स्रोत

0

जे , ⁵⁴ ⁴⁷ ⁴⁵ 39 बाइट्स

(0?@{[)^:((-1&{)~(<*/@,0<:[)2{[)^:_{~&1

इसे ऑनलाइन आज़माएं!

इनपुट को 3 x 2 ग्रिड की तरह लें:

grid_height  grid_width
inner_top    inner_left
inner_height inner_width

पूरे ग्रिड पर एक यादृच्छिक बिंदु चुनें: 0?@{[
आंतरिक आयत के ऊपरी-बाएँ बिंदु द्वारा इसे नीचे और नीचे शिफ्ट करें: (-1&{)~
चरण 1 पर लौटें यदि चुना गया स्थान (<*/@,0<:[)समान रूप से स्थानांतरित आंतरिक आयत के भीतर हो 2{[। अन्यथा मूल, अशिक्षित यादृच्छिक बिंदु पर लौटें।
एक बिंदु के साथ पूरी प्रक्रिया को हम जानते हैं कि अमान्य है, अर्थात् आंतरिक आयत के ऊपरी बाएं बिंदु, इनपुट सूची के तत्वों 2 और 3 द्वारा परिभाषित किया गया है: {~&1

एक और दृष्टिकोण, 45 बाइट्स

{.#:i.@{.(?@#{])@-.&,([:<@;&i./{:){1&{|.i.@{.

इसे ऑनलाइन आज़माएं!

यह एक वैचारिक रूप से सरल है, और लूपिंग से परेशान नहीं करता है। इसके बजाय, हम 0 से (wxh) संख्याओं के एक मैट्रिक्स का निर्माण करते हैं, इसे आंतरिक शुरुआती बिंदु से स्थानांतरित करते हैं, बस (0, 0) (इनर डब्ल्यू, इनर एच) सबग्रिड के बिंदुओं को पकड़ते हैं, उन्हें समग्र रूप से हटाते हैं। दोनों को समतल करने के बाद, शेष में से एक को चुनें, और पूर्णांक को एक बिंदु में परिवर्तित करके divmod का उपयोग करें<.@% , |~

— जोनाह
स्रोत

किसी नक्शे के भीतर दिए गए आयत के बाहर एक यादृच्छिक बिंदु उत्पन्न करें

परिचय

चुनौती

इनपुट

उत्पादन

उदाहरण

पायथन 2 , 114 106 102 101 बाइट्स

आर , 89 73 बाइट्स

05AB1E , 23 21 20 18 17 बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 110 बाइट्स

पॉवरशेल , 85 73 बाइट्स

जूलिया , 76 71 67 बाइट्स

जेली , 11 बाइट्स

व्याख्या

अजगर 2 , 100 बाइट्स

जावा (ओपनजेडके 8) , 100 बाइट्स

वोल्फ्राम भाषा (गणितज्ञ) , 84 68 60 बाइट्स

चारकोल , 55 43 बाइट्स

पर्ल 5 -ap , 84 बाइट्स

स्काला , 172 बाइट्स

जे , 54 47 45 39 बाइट्स

एक और दृष्टिकोण, 45 बाइट्स

पर्ल 5 `-ap` , 84 बाइट्स

जे , ⁵⁴ ⁴⁷ ⁴⁵ 39 बाइट्स