सोलर सिस्टम बनाएं

39

पहचान

यह एक वास्तविक समस्या पर आधारित है जिसे मैंने हाल ही में कंप्यूटर गेम बनाते समय सामना किया था और मुझे लगा कि यह कोड-गोल्फ के एक अच्छे दौर के लिए बनेगा ।

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

मेरे खेल में आकाशगंगा प्रक्रियात्मक रूप से उत्पन्न हुई है और दिए गए तारों के लिए ग्रह प्रकारों का चयन करने के लिए बेतरतीब ढंग से चयन किया गया है जो कि 'स्टेटमेंट नर्क' है!

चुनौती

आपकी विधि को न्यूनतम ताप सीमा, अधिकतम ताप सीमा और एक यादृच्छिक संख्या के आधार पर, ग्रह के प्रकार के लिए उपयुक्त ग्रह प्रकारों की सूची में से एक ग्रह का चयन करना चाहिए। सादगी के लिए यह चुनौती केवल हमारे सूरज की तरह एक वर्ग जी स्टार का उपयोग करेगी।

इनपुट

heatस्टार से ग्रह द्वारा प्राप्त गर्मी की मात्रा का प्रतिनिधित्व करते हुए रेंज 4 से 11 में एक पूर्णांक ।

चर

यह तालिका संभावित ग्रहों को दर्शाती है heat। आपकी विधि को पहले गर्मी मिनट और गर्मी अधिकतम के आधार पर उपलब्ध विकल्पों को संकीर्ण heatकरना चाहिए , दोनों के बीच या पर गिरना चाहिए। उदाहरण के लिए 10 की गर्मी के साथ एकमात्र विकल्प डेजर्ट, आयरन और लावा होगा।

Planet type    Heat min   Heat max   Random Chance
Gas Giant         4          9            15
Ice               4          6            10
Ice Giant         4          6            10
Gaia class        5          7            10
Dense Atmosphere  7          9            10
Desert            7          10           25
Iron              7          10           14
Lava             10          11           6

इसके बाद, किसी ग्रह की संभावना (शेष विकल्पों में) को चुना जाना उसकी यादृच्छिक संभावना है जो सभी विकल्पों के यादृच्छिक अवसरों के योग से विभाजित होता है।

उपरोक्त उदाहरण में, आयरन के चुने जाने की संभावना है 14/(25+14+6)।

उत्पादन

ग्रह प्रकार को एक स्ट्रिंग के रूप में लौटाएं।

तर्क तीर-कमान से बचने के लिए सबसे अच्छा है। सबसे छोटा कोड जीतता है, रचनात्मकता के लिए सभी दौर को इंगित करता है। हैप्पी गोल्फिंग!

code-golf  random 
— चिरायता
स्रोत
क्या "गैया वर्ग" के "वर्ग" को हर चीज की तरह भुनाना चाहिए?
— जोनाथन एलन
@JonathanAllan यह कम मामला है क्योंकि यह एक उचित संज्ञा नहीं है
— Absinthe
1
@Absinthe फिर घना एक वायुमंडल अपरकेस क्यों है ?
— 15
17
... किसी ने कहा है? | PPCG में आपका स्वागत है, और अच्छी पहली चुनौती है!
— user202729
3
@EricDuminil उर्फ ​​एरोहेड एंटी-पैटर्न, उर्फ ​​नेस्टेड-इफ-स्टेटमेंट-हेल! wiki.c2.com/?ArrowAntiPattern
— Absinthe

जवाबों:

12

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

“'ĖøÆḳƙ’ḃ7ṣ6+\+3r/ċ€×“½½½½©ÐÇı‘
“ŀỊẋ8ƒ³ẈRɼƈñqẋẏȧɱḌ<ṄỴḳ⁾ÆʋeẒĊ'@ƬØƓƝ}ḟ¬»ỴW€ẋ"ÇẎX

एक पूर्णांक लिंक जो एक पूर्णांक को स्वीकार करता है ( [४,११] ) में जो पात्रों की सूची देता है।

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

कैसे?

ग्रहों की ऊष्मा श्रृंखला को सूचियों की एक सूची के रूप में बनाता है और उन सूचियों में शून्य ऊष्मा की घटनाओं को गिनाता है जो शून्य और उन लोगों की सूची प्राप्त करने के लिए जो ग्रह प्रकार संभव हैं, फिर आठ ग्रह प्रकारों की संभावना संख्याओं से गुणा करते हैं वितरण प्राप्त करें। वितरण का उपयोग ग्रह प्रकार के नामों को दोहराने के लिए किया जाता है, और अंत में एक समान यादृच्छिक विकल्प बनाया जाता है।

“'ĖøÆḳƙ’ḃ7ṣ6+\+3r/ċ€×“½½½½©ÐÇı‘ - Link 1, getDistribution: integer
“'ĖøÆḳƙ’                        - base 250 integer = 39824688429662
        ḃ7                      - to bijective-base 7 = [1,1,2,4,7,1,4,4,6,2,2,2,2,1,5,3,3]
          ṣ6                    - split at sixes = [[1,1,2,4,7,1,4,4][2,2,2,2,1,5,3,3]]
             \                  - cumulative reduce with:
            +                   -   addition = [[1,1,2,4,7,1,4,4][3,3,4,6,8,6,7,7]]
              +3                - add three = [[4,4,5,7,10,4,7,7],[6,6,7,9,11,9,10,10]]
                 /              - reduce with:
                r               -   inclusive range = [[4,5,6],[4,5,6],[5,6,7],[7,8,9],[10,11],[4,5,6,7,8,9],[7,8,9,10],[7,8,9,10]]
                  ċ€            - count (input) in €ach e.g. for 5: [1, 1, 1, 0,0, 1, 0, 0]
                     “½½½½©ÐÇı‘ - list of code-page indices        [10,10,10,10,6,15,14,25]
                    ×           - multiply                         [10,10,10, 0,0,15, 0, 0]

“ ... »ỴW€ẋ"ÇẎX - Main link: integer
“ ... »         - compressed string = "Ice\nIce Giant\nGaia class\nDense Atmosphere\nLava\nGas Giant\nIron\nDesert"
       Ỵ        - split at new lines = ["Ice","Ice Giant","Gaia class","Dense Atmosphere","Lava","Gas Giant","Iron","Desert"]
        W€      - wrap €ach in a list
            Ç   - call last link (1) as a monad e.g. for 5: [10,10,10,0,0,15,0,0]
           "    - zip with:
          ẋ     -   repeat e.g. for 5:  [["Ice","Ice","Ice","Ice","Ice","Ice","Ice","Ice","Ice","Ice"],["Ice Giant","Ice Giant","Ice Giant","Ice Giant","Ice Giant","Ice Giant","Ice Giant","Ice Giant","Ice Giant","Ice Giant"],["Gaia class","Gaia class","Gaia class","Gaia class","Gaia class","Gaia class","Gaia class","Gaia class","Gaia class","Gaia class"],["Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant"]]
             Ẏ  - tighten               ["Ice","Ice","Ice","Ice","Ice","Ice","Ice","Ice","Ice","Ice","Ice Giant","Ice Giant","Ice Giant","Ice Giant","Ice Giant","Ice Giant","Ice Giant","Ice Giant","Ice Giant","Ice Giant","Gaia class","Gaia class","Gaia class","Gaia class","Gaia class","Gaia class","Gaia class","Gaia class","Gaia class","Gaia class","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant","Gas Giant"]
              X - a random choice from that list
— जोनाथन एलन
स्रोत
पागल! बहुत बढ़िया।
— Absinthe
@ अबिंशे आप बस उत्थान कर सकते हैं। साइड नोट: कोड गोल्फ पर हम आम तौर पर जवाब स्वीकार नहीं करते हैं।
— user202729
2
@ user202729 मैं एक-दो दिन में वोट जोड़ दूंगा। मैं जेली के लिए GitHub पृष्ठ पर देख रहा था जो इस कोड को जानने की कोशिश कर रहा था। मेरा मानना ​​है कि पागल! सबसे उपयुक्त है :)
— Absinthe
2
@Absinthe हाँ, मेरा मानना ​​है कि एक वर्णनात्मक खंड अक्सर गैर-गूढ़ भाषा प्रस्तुतियाँ के लिए भी एक अच्छी बात है :)
— जोनाथन एलन
3
आप लोग वास्तव में पागल हैं।
— सेल्वेक
7

आर , 225 223 183 बाइट्स

188 बाइट्स तक ले जाने के लिए चालाक रिफैक्टिंग के लिए Giuseppe का धन्यवाद; कम निरर्थक संख्या अभ्यावेदन का उपयोग करके शेष पांच का मुंडन किया गया।

i=scan()-4
sample(c("Gas Giant","Ice","Ice Giant","Gaia class","Dense Atmosphere","Desert","Iron","Lava")[l<-c(0,0,0,1,3,3,3,6)<=i&c(5,2,2,3,5,6,6,7)>=i],1,,c(3,2,2,2,2,5,2.8,1.2)[l])

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

— rturnbull
स्रोत
यह एक अच्छा तरीका है, मुझे अपने बयान को हटाने के बारे में सोचना पड़ सकता है यदि सी # :) में इस के पक्ष में भूलभुलैया हो जाए
— Absinthe
मैं तार्किक सूचकांक बचत के बजाय का उपयोग कर संदेह है with, data.frameऔर subsetकम हो जाएगी।
— ग्यूसेप
2
— ग्यूसेप
@Giuseppe, आप शायद ग्रह डेटा के साथ मेरी कुछ चालों का उपयोग करके कुछ अधिक बाइट्स प्राप्त कर सकते हैं , लेकिन मुझे लगता है कि मैं बाकी डेटा से संभाव्यता वेक्टर को अलग करने के आपके विचार का उपयोग करके मेरा भी सुधार करूंगा।
— किरिल एल।
4

जावास्क्रिप्ट 212

6 बाइट्स संपादित करें जोक्स जोनाथन एलन को बचाएं

h=>[963,640,640,649,667,1628,924,437].map((z,i)=>(z/8&7)+4>h|z%8+6<h?0:t=r.push(...Array(z>>6).fill(i)),r=[])&&"Gas Giant,Ice,Ice Giant,Gaia class,Dense Atmosphere,Desert,Iron,Lava".split`,`[r[t*Math.random()|0]]

कम गोल्फ वाला

h=>( 
   r = [],
   // heat min,max and chance encoded in base 8 with offsets
   // min range 4 to 10, with offset 4, 0 to 6
   // max range 6 to 11, with offset 6, 0 to 5
   [(4-4)*8 + 9-6 + 15*64,
    (4-4)*8 + 6-6 + 10*64,
    (4-4)*8 + 6-6 + 10*64,
    (5-4)*8 + 7-6 + 10*64,
    (7-4)*8 + 9-6 + 10*64,
    (7-4)*8 + 10-6+ 25*64,
    (7-4)*8 + 10-6+ 14*64,
    (10-4)*8+ 11-6+  6*64]
   .forEach( (z,i) => (
      min = (z / 8 & 7) + 4, 
      max = z % 8 + 6,
      chance = z >> 6,
      min > h || max < h 
      ? 0 // out of range
      // add current position i repeated 'chance' times
      // array size in t
      : t = r.push(...Array(chance).fill(i))
   ),
   pos = r[t * Math.random() | 0],
   ["Gas Giant", "Ice", "Ice Giant", "Gaia class", "Dense Atmosphere", "Desert", "Iron", "Lava"][pos]
)

परीक्षा

var F=
h=>[963,640,640,649,667,1628,924,437].map((z,i)=>(z/8&7)+4>h|z%8+6<h?0:t=r.push(...Array(z>>6).fill(i)),r=[])&&"Gas Giant,Ice,Ice Giant,Gaia class,Dense Atmosphere,Desert,Iron,Lava".split`,`[r[t*Math.random()|0]]

function test()
{
   var heat=+H.value
   var i,result,hashtable={},rep=1e5
   for (i=0;i<rep;i++)
     result = F(heat),
     hashtable[result] = -~hashtable[result]
 
   console.log('Input',heat)
   for (i in hashtable)
   {
     console.log(i,(hashtable[i]/rep*100).toFixed(2),'%')
   }
}
<input id=H type=number min=1 max =15 value=10>
<button onclick='test()'>Test</button>
स्निपेट का विस्तार करें

— edc65
स्रोत
आपके आधार 16 संख्याओं के एक जोड़े 1 बंद (होना चाहिए [3913, 2630, 2630, 2647, 2681, 6522, 3706, 1707])
— जोनाथन एलन
मुझे लगता है कि (लेकिन 100% नहीं कर रहा हूँ) आप की जगह 2 बचा सकता है (z/16&15)के साथ z/16&15। भले ही, आप तीन और छह के ऑफसेट के साथ एक आधार 8 संपीड़न का उपयोग करके 6 बाइट्स बचा सकते हैं ... का उपयोग [971,648,648,657,675,1636,932,445]करें z/8&7+3, z%8+6और z>>6:)
— जोनाथन एलन
@JonathanAllan ऑफसेट! महान विचार, thx
— edc65
@JonathanAllan के लिए मुझे कोष्ठक की आवश्यकता है (z/8&7)+4क्योंकि &कम प्राथमिकता है - यह होगा7/8&(7+4)
— edc65
1
@ शगुन क्या आपने टिप्पणी ऊपर देखी है? (लंबी कहानी छोटी: नहीं)
— edc65
4

नारियल , 214 195 बाइट्स

t->choice..sum([[n]*g(p)*(g(a)<t<g(b))for*n,a,b,p in'Gas Giant3AF_Ice37A_Ice Giant37A_Gaia class48A_Dense Atmosphere6AA_Desert6BP_Iron6BE_Lava9C6'.split('_')],[])
from random import*
g=int$(?,36)

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

एक पायथन पोर्ट 203 200 बाइट लंबा होगा:

lambda t:choice(sum([[n]*int(p,36)*(int(a)<t<int(b,36))for*n,a,b,p in'Gas Giant3AF_Ice37A_Ice Giant37A_Gaia class48A_Dense Atmosphere6AA_Desert6BP_Iron6BE_Lava9C6'.split('_')],[]))
from random import*

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

— OVS
स्रोत
1
दिलचस्प है, लेखन के समय, आपका पायथन पोर्ट अन्य सभी पायथन समाधानों को हरा देता है!
— किरिल एल।
4

चारकोल , 115 111 बाइट्स

≔Ｉ⁻Ｎ³θＦ⁸«≔§⪪”↷＆∧⬤.YLφκ¦(⁼；σ≕]✂↙ζＣ” ιη¿›θη¿‹θ§η¹ＦＩ✂η²⊞υ黧⪪”↓(″1↨▷]Ｕ,&ζ^iＩ″ＲＳＹ≡´⍘'#﹪υＶw5Ｖu>D<U5r6⁰Ｑ▷Ｚ◨⌕⁸ΣεCＺ”¶‽υ

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

≔Ｉ⁻Ｎ³θ

3 को इनपुट से घटाएं ताकि एकल अंकों के खिलाफ तुलना की जा सके।

Ｆ⁸«≔§⪪”↷＆∧⬤.YLφκ¦(⁼；σ≕]✂↙ζＣ” ιη

0715 0410 0410 1510 3710 3825 3814 696रिक्त स्थान पर स्ट्रिंग को विभाजित करें (रिक्त स्थान कॉमा से बेहतर संपीड़ित करने के लिए लगता है लेकिन मैंने किसी अन्य वर्ण की कोशिश नहीं की) और प्रत्येक भाग पर लूप।

¿›θη¿‹θ§η¹ＦＩ✂η²⊞υι»

पहले और दूसरे अंक के खिलाफ इनपुट की तुलना करें और यदि यह बीच में है, तो लूप इंडेक्स को पूर्वनिर्धारित रिक्त सूची में दिए गए समय की संख्या को धक्का दें, इस प्रकार इसे पॉप्युलेट करें।

§⪪”↓(″1↨▷]Ｕ,&ζ^iＩ″ＲＳＹ≡´⍘'#﹪υＶw5Ｖu>D<U5r6⁰Ｑ▷Ｚ◨⌕⁸ΣεCＺ”¶‽υ

नए सिरे पर ग्रहों की सूची को विभाजित करें (फिर, किसी कारण से अल्पविराम से बेहतर) और सूची से यादृच्छिक रूप से चुने गए सूचकांक के अनुरूप तत्व का चयन करें।

— नील
स्रोत
अच्छा है। प्रत्येक ग्रह के लिए अलग-अलग संभावनाओं में यादृच्छिक (यू) कारक कैसे होता है? (मैं चारकोल के बारे में कुछ नहीं जानता)।
— Absinthe
यह एक सूची में से एक सूची को चुन रहा है जिसमें प्लैनेट टाइप सूचकांकों के सही वितरण के कारण "लूप इंडेक्स को दिए गए समय की संख्या को पूर्वनिर्धारित खाली सूची पर धकेलना, इस प्रकार इसे पॉप्युलेट करना है।" तो ग्रह का नाम पाने के लिए चुने गए सूचकांक का उपयोग करना।
— जोनाथन एलन
@JonathanAllan को मिला, धन्यवाद
— Absinthe
111 बाइट्स , मुझे लगता है? सामान्य तौर पर चरित्र वर्ग में पहले वर्णों का उपयोग करने का प्रयास करें, संपीड़न # 11 देखें। डिफ़ॉल्ट आदेश एक और बाइट बचाता है, लेकिन यह मूल रूप से केवल तभी है जब आपके पास केवल प्रतीक हैं
— केवल
@ ASCII- केवल कीचड़ के रूप में साफ़ करें ... क्यों नई कड़ियाँ बेहतर हैं लेकिन दूसरी स्ट्रिंग के लिए रिक्त स्थान हैं?
— नील
3

आर , 196 193 190 175 171 बाइट्स

sample(readLines(,8),1,,c(3,2,2,2,2,5,2.8,1.2)*((x=scan()-3)>c(0,0,0,1,3,3,3,6)&x<c(7,4,4,5,7,8,8,9)))
Gas Giant
Ice
Ice Giant
Gaia class
Dense Atmosphere
Desert
Iron
Lava

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

प्रारंभ में @rturnbull द्वारा इस समाधान से प्रेरित, हालांकि दोनों प्रस्तुतियाँ काफी विकसित हुई हैं, यह अब मूल लेखक के विचारों का मिश्रण है, @Giuseppe जो टिप्पणियों में बहुत मददगार रहा है, और मेरा। यहां उन प्रमुख बिंदुओं का सारांश दिया गया है जो बाइट की गिनती को नीचे लाने में मदद करते हैं:

  • सीएसवी के रूप में ग्रह डेटा को एन्कोडreadLines करना स्ट्रिंग के चारों ओर बड़ी संख्या में उद्धरण वर्णों से बचने के लिए नाम एकत्र करना।

  • गर्मी पैरामीटर ट्वीक ताकि हम इस्तेमाल कर सकते हैं <और >के बजाय संकेत <=और >=।

  • गर्मी से डेटा स्वरूप बदलने Heat min, Heat maxके लिए Heat min, Heat Deltaदोहरे अंक संख्या से छुटकारा पाने के।
    -3 से सभी नंबरों को शिफ्ट करके बदला गया

  • सभी ग्रह संभावनाओं को 5 से विभाजित करना जिसके परिणामस्वरूप कुछ कम अंक भी होते हैं।

  • बूलियंस के वेक्टर के साथ ग्रह संभावनाओं के वेक्टर को गुणा करना (यह दर्शाता है कि क्या हमारे इनपुट गर्मी आवश्यकताओं को संतुष्ट करता है) अनुपयुक्त ग्रहों की संभावनाओं को कम करने के लिए।

संभवतया, कुछ प्रकार के डेटा संपीड़न को लागू करके कुछ और बाइट्स प्राप्त किए जा सकते हैं।
मुझे लगता है, अब और नहीं।

— किरिल एल।
स्रोत
1
t=इसके बजाय text=3 बाइट्स भी बचाएगा।
— ग्यूसेप
1
— Giuseppe
ठोस उत्तर, हालांकि, read.csvएक एकल स्तंभ के लिए उपयोग readLinesकरने से पूरी तरह से उद्धरण से छुटकारा पाने का सुझाव दिया गया है, हालांकि आपको स्पष्ट रूप से सेट करना हैn
— Giuseppe
@Giuseppe, हालांकि यह 171 बाइट्स है, क्योंकि आपने ऑपरेटर वरीयता को बनाए रखने के लिए आवश्यक कोष्ठक भी हटा दिए हैं, और आपका संस्करण गलत संभावनाएं देता है। फिर भी, एक शानदार सुझाव!
— किरिल एल।
ओह मुझे आश्चर्य है कि उन कोष्ठक कहाँ से आए थे ....
— Giuseppe
3

पायथन, 282 बाइट्स , 261 बाइट्स:

from random import*
i,p,l=input(),[('Gas Giant',3,11,15),("Ice",3,7,10),("Ice Giant",3,7,10),("Gaia Class",4,8,10),("Dense Atmosphere",6,10,10),("Desert",6,11,25),("Iron",6,11,14),("Lava",9,12,6)],[]
for x in p:exec"l+=x[0],;"*(x[1]<i<x[2])*x[3]
print choice(l)

बहुत आसान है - काफी यकीन है कि यह और अधिक गोल्फ हो सकता है - अभी भी ग्रह रेंज और संभावना डेटा का प्रतिनिधित्व करने के लिए एक बेहतर तरीके की तलाश कर रहा है। यदि मैं ग्रह प्रकार की सीमा में हूं, तो इसे संभावना के अनुसार सूची में जोड़ देता है, फिर बेतरतीब ढंग से प्रिंट करता है।

संपादित करें: जोनाथन फ्रेच को क्रेडिट के साथ - कुछ बाइट्स को बंद करने के लिए लूप के लिए रेडी करें। सूची में वस्तुओं को जोड़ने का बेहतर तरीका

— Chromane
स्रोत
3
PPCG में आपका स्वागत है! सुनिश्चित नहीं है कि आपने बाइट्स कैसे गिना है, लेकिन मुझे केवल 283 मिल रहे हैं। यदि 4 बाइट्स के बजाय इंडेंट एक टैब है तो कम है।
— मार्टिन एंडर
1
i in range(x[1], x[2])विनिर्देश के विपरीत, गर्मी के ऊपरी किनारे को बाहर नहीं करता है?
— ग्रिफ़ेर
1
— जोनाथन फ्रीच
1
क्या यह कोई मदद हो सकती है? p,d="Gas Giant,Ice,Ice Giant,Gaia class,Dense Atmosphere,Desert,Iron,Lava".split(","),[ord(i)-10 for i in"#"] d=[[p[x//3]]+d[x:x+3]for x in range(0,len(d),3)]
— मूंछें
1
@ क्रोमन माफी यह लगता है कि टिप्पणियों ने कुछ पात्रों को छीन लिया।
— मूंछें 0
2

ऑक्टेव स्टैटिस्टिक्स पैकेज के साथ, 178 176 174 158 बाइट्स

@(h)randsample(strsplit('Gas Giant,Ice,Ice Giant,Gaia class,Dense Atmosphere,Desert,Iron,Lava',','),1,1,('UPPPP_TL'-70).*(h>'IIIJLLLO'-70&h<'PMMNPQQR'-70)){1}

कोड एक अनाम फ़ंक्शन को परिभाषित करता है जो एक नंबर इनपुट करता है और एक स्ट्रिंग आउटपुट करता है।

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

व्याख्या

कोड

@(h)

एक अनाम फ़ंक्शन को इनपुट के साथ परिभाषित करता है h।

डोर

'Gas Giant,Ice,Ice Giant,Gaia class,Dense Atmosphere,Desert,Iron,Lava'

का उपयोग कर अल्पविराम में विभाजित है

strsplit(...,',')

परिणाम स्ट्रिंग का एक सेल सरणी है, जहां प्रत्येक स्ट्रिंग एक ग्रह वर्ग है।

कोड

'IIIJLLLO'-70

दिखाए गए स्ट्रिंग को परिभाषित करता है और 70इसके वर्णों के कोड बिंदुओं से घटाता है। यह न्यूनतम गर्मी मानों का मान देता है माइनस 1 , अर्थात [3 3 3 4 6 6 6 9]।

इसी तरह,

'PMMNPQQR'-70

अधिकतम ताप मानों की सरणी 1 से अधिक है , अर्थात [10 7 7 8 10 11 11 12]।

तुलना

h>...&h<...

एक सरणी दें trueया falseसंकेत दें कि कौन से ग्रह वर्ग संभव हैं।

दूसरी ओर,

'UPPPP_TL'-70

, यादृच्छिक मौका मूल्यों की सरणी को परिभाषित करता है [15 10 10 10 10 25 14 6]।

आपरेशन

(...).*(...)

बाद के दो सरणियों के तत्व के लिहाज से गुणा (है trueऔर falseतरह व्यवहार 0और 1क्रमशः)। यह एक सरणी देता है जहां प्रत्येक ग्रह वर्ग के पास या तो इसका यादृच्छिक मौका है, या 0यदि इनपुट के आधार पर वह वर्ग संभव नहीं है। इस नमूने का उपयोग यादृच्छिक नमूने में भार के रूप में किया जाएगा

फ़ंक्शन कॉल

randsample(...,1,1,...)

सेल के तार (पहले इनपुट तर्क) से सेल में से एक का चयन करता है, वजन (चौथे इनपुट तर्क) की गणना की सरणी का उपयोग कर। विशेष रूप से, फ़ंक्शन randsampleस्वचालित रूप से संभावनाओं को भार को सामान्य करता है, और फिर उन संभावनाओं के साथ यादृच्छिक चयन करता है। परिणाम एक सेल सरणी है जिसमें एक स्ट्रिंग है। कोड

{1}

उस स्ट्रिंग को निकालने के लिए उपयोग किया जाता है, जो फ़ंक्शन आउटपुट का गठन करता है।

— लुइस मेंडो
स्रोत
2
महान व्याख्या, धन्यवाद। शानदार स्कोर भी।
— Absinthe
1

पर्ल 5 ( -p), 230 बाइट्स

@a=(['Gas Giant',4,9,15],[Ice,4,6,10],['Ice Giant',4,6,10],['Gaia class',5,7,10],['Dense Atmosphere',7,9,10],[Desert,7,10,25],[Iron,7,10,14],[Lava,10,11,6]);//;map{push@b,($$_[0])x($$_[3]*($$_[1]<=$'&&$'<=$$_[2]))}@a;$_=$b[rand@b]

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

— Xcali
स्रोत
यदि आप एक मिनट हीट को हटाते हैं और एक को अधिकतम हीट में जोड़ते हैं (जो कि [Ice,4,5,11]इसके बजाय [Ice,4,6,10]आदि को देगा) तो आप <इसके बजाय <=और >इसके बजाय >=2 बाइट्स को बचाने के लिए उपयोग कर पाएंगे । (हाँ, यह बहुत नहीं है ...)
— दादा
1

निम , 314 298 294 बाइट्स

import random,sequtils
proc c(h:int)=
 var a= @[""]
 a.del 0
 for n in[("Gas Giant",4,9,15),("Ice",4,6,10),("Ice Giant",4,6,10),("Gaia Class",5,7,10),("Dense Atmosphere",7,9,10),("Desert",7,10,25),("Iron",7,10,14),("Lava",10,11,6)]:(if h>=n[1]and h<=n[2]:a.add repeat(n[0],n[3]))
 echo random a

लूप के लिए अब एक पंक्ति में, कोई वापसी नहीं, कम बाइट से लेकर निहित प्रकार तक

4 स्थान हटाए गए (धन्यवाद केविन )

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

— Panda0nEarth
स्रोत
मैंने कभी भी प्रोग्राम नहीं किया है Nim, लेकिन मुझे लगता है कि आप चार स्थानों को गोल्फ कर सकते हैं: एक पर for n in[(; और तीन बजे if h>=n[1]and h<=n[2]।
— केविन क्रूज़सेन
1

05AB1E , 78 76 बाइट्स

”Œï²°™Ä²° Gaia classêη•™Äµ‰Ÿ± Lava”#8äðýā<•ŒEŽuS,•2ôו9èÁnÇ∞Λ•SÌ2ôεŸIå}ÏSΩè

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

व्याख्या

”Œï²°™Ä²° Gaia classêη•™Äµ‰Ÿ± Lava”
स्ट्रिंग को धक्का देता है Gas Giant Ice Giant Gaia class Dense Atmosphere Ice Desert Iron Lava

#                                          # split on spaces
 8ä                                        # divide into 8 parts
   ðý                                      # join each by spaces
     ā<                                    # push the range [0 ... 7]
       •ŒEŽuS,•                            # push 151010101025146
               2ô                          # split into pieces of 2
                                           # results in [15, 10, 10, 10, 10, 25, 14, 6]
                 ×                         # repeat each number in the range by these amounts
                                           # results in ['000000000000000', '1111111111', '2222222222', '3333333333', '4444444444', '5555555555555555555555555', '66666666666666', '777777']
                  •9èÁnÇ∞Λ•                # push 2724355724585889
                           S               # split to list of digits
                            Ì              # decrement each twice
                                           # results in [4,9,4,6,5,7,7,9,4,6,7,10,7,10,10,11]
                             2ô            # split into pieces of 2
                                           # results in [[4, 9], [4, 6], [5, 7], [7, 9], [4, 6], [7, 10], [7, 10], [10, 11]]
                               εŸIå}       # apply to each pair
                                Ÿ          # range [a ... b]
                                 Iå        # check if input is contained in the range
                                           # ex, for input 10: [0, 0, 0, 0, 0, 1, 1, 1]
                                    Ï      # keep only the indices which are true
                                           # ex, for input 10: ['5555555555555555555555555', '66666666666666', '777777']
                                     S     # split to list of digits
                                      Ω    # pick one at random
                                       è   # index into the list of strings with this
— Emigna
स्रोत
1

पायथन 3, 199 194 बाइट्स

from random import*
lambda n:choices("Ice|Ice Giant|Gas Giant|Gaia class|Dense Atmosphere|Desert|Iron|Lava".split('|'),[(0x33b2a53d4a>>5*i&31)*(0xc07878380e3f0707>>8*i+n-4&1)for i in range(8)])

hअलग-अलग बिट मास्क और रैंडम चांस वैल्यू (स्पष्टीकरण देखें) में विभाजित होने से सूची बोध में एक असाइनमेंट को समाप्त करने hऔर सरल बनाने में कुछ बाइट्स बचते हैं range()।

पिछला समाधान

from random import*
h=0xc033c39e3270a0e51fbc1d40ea
lambda n:choices("Ice|Ice Giant|Gas Giant|Gaia class|Dense Atmosphere|Desert|Iron|Lava".split('|'),[(h>>i&31)*(h>>i+n+1&1)for i in range(0,104,13)])

एक अनाम फ़ंक्शन को परिभाषित करता है जो एक इंट लेता है और ग्रह प्रकार लौटाता है।

प्रत्येक ग्रह प्रकार के लिए, 13-बिट मान की गणना की गई थी। शीर्ष 8 बिट्स उस ग्रह प्रकार के लिए वैध ताप मानों के एक बिट मास्क को परिभाषित करते हैं। नीचे के 5 बिट्स उस ग्रह प्रकार के लिए यादृच्छिक मौका हैं। उदाहरण के लिए, "गैया वर्ग" 4 से 7 के मानों के लिए एक मान्य प्रकार है, इसलिए इसका मुखौटा है 0b00001111। यह 10 का यादृच्छिक मौका है, या 0b01010। उन्हें मिलाकर यह 0b0000111101010"गिया वर्ग" प्रकार के लिए 13-बिट मान का परिणाम है । प्रत्येक ग्रह प्रकार के लिए 13-बिट मानों को मान प्राप्त करने के लिए संक्षिप्त किया गया है h(सबसे कम 13 बिट "आइस" ग्रह ग्रह के लिए हैं)। (नया उत्तर इन मूल्यों को संयोजित नहीं करता है)।

यह सूची 13-बिट मान से अधिक वजन की सूची बनाने के लिए समझ में आती है, जहां वजन एक यादृच्छिक मौका है यदि ग्रह प्रकार दिए गए गर्मी मूल्य के लिए एक वैध विकल्प है, और अन्यथा शून्य। प्रत्येक ग्रह प्रकार के लिए, (h>>i&31)उस ग्रह प्रकार के लिए यादृच्छिक मौका निकालता है। (h>>i+n+1&1)1 का मूल्यांकन करता है यदि ग्रह प्रकार गर्मी मूल्य के लिए एक वैध विकल्प है nऔर 0 का मूल्यांकन करता है अन्यथा।

लाइब्रेरी फ़ंक्शन random.choices(choices, weights)वजन की सूची के आधार पर विकल्पों की सूची में से एक आइटम का चयन करता है।

— RootTwo
स्रोत
i+n+1हो सकता है i-~n। TIO
— OVS
1

रूबी , 214 193 189 बाइट्स

->h{'Gas Giant,Desert,Iron,Lava,Ice,Ice Giant,Gaia class,Dense Atmosphere'.split(?,).zip(31006330.digits,75449887.digits,[15,25,14,6]).flat_map{|n,m,x,r|m<h-3&&x>h-3?[n]*(r||10):[]}.sample}

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

— आसोन तुहिद
स्रोत
क्षमा करें, मुझे आउटपुट नहीं मिला, क्या यह सूची में पहला आइटम होगा?
— Absinthe
@ अबिंशे मैंने कुछ हेडिंग जोड़े, फिर से जाँच करें। यह 4 से 11 तक सभी गर्मी के स्तर और प्रत्येक के लिए एक यादृच्छिक रूप से उत्पन्न ग्रह है
— असोन तुहिद
आह, मैं इसे धन्यवाद देता हूं, हालांकि आदर्श रूप से केवल एक स्ट्रिंग आउटपुट होना चाहिए
— Absinthe
@ अबिंशे आप सही कह रहे हैं, यह सिर्फ मेरा खुद का टेस्ट कोड था, अब आप जो हीट वैल्यू चाहते हैं उसे इनपुट कर सकते हैं और यह 1 परिणाम देता है
— असोन तुहिद
1

हास्केल , 377 364 358 318 312 270 265 262 256 251 बाइट्स

import System.Random
f h|x<-[n|(n,(a,b,c))<-zip(lines"Gas Giant\nIce\nIce Giant\nGaia class\nDense Atmosphere\n
Desert\nIron\nLava")$zip3[4,4,4,5,7,7,7,10][9,6,6,7,9,10,10,11][15,10,10,10,10,25,14,6],h<=
b,h>=a,_<-[1..c]]=(x!!)<$>randomRIO(0,length x-1)

(मैंने अच्छे प्रिंटआउट के लिए लाइनब्रेक जोड़े हैं)। कार्य कहते हैं, "वापसी", नहीं "प्रिंट", तो fएक समारोह है जिसमें बेतरतीब ढंग से चुना ग्रह नाम देता है IOइकाई, f :: Int -> IO String।

mainहै main = do {f 10 >>= print}( हास्केल सुझावों गोल्फ यह शामिल नहीं किये जाते कहते हैं)। प्रिंटों

"Iron"     -- or "Desert", or "Lava"

(संपादन: &बेस का मामला हटा दिया mainगया; बाहर निकल गया; चौगुनी में बदल गया unzip, और पैटर्न गार्ड में बदल गया और लाइकोनी से>>= निम्नलिखित सुझावों के लिए धन्यवाद !! ने नाम को दोहराते हुए जेली समाधान से दृष्टिकोण लागू किया , नामों को स्पष्ट प्रकार की अब आवश्यकता नहीं है; ; लकोनी की एक और सलाह 3 और बाइट्स बचाती है; इसे एक फंक्शन बनाया ; चैट रूम से सलाह को लागू किया )। IO

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

— विल नेस
स्रोत
अच्छा! टिप्पणियों की बाढ़ से बचने के लिए, आप अपने जवाब पर चर्चा करने के लिए मोनाड्स और पुरुषों के हास्केल चैट रूम में शामिल हो सकते हैं ।
— लकोनी
0

जावा 8, 398 384 बाइट्स

n->{String r="",a[];for(String x:"456789~Gas Giant~15;456~Ice~10;456~Ice Giant~10;567~Gaia class~10;789~Dense Atmosphere~10;78910~Desert~25;78910~Iron~14;1011~Lava~6".split(";"))if(x.split("~")[0].contains(n))r+=x+";";long t=0,u=0;for(String x:(a=r.split(";")))t+=new Long(x.split("~")[2]);t*=Math.random();for(String x:a)if((u+=new Long((a=x.split("~"))[2]))>t)return a[1];return"";}

यह निश्चित रूप से कुछ और गोल्फ हो सकता है, लेकिन स्ट्रिंग्स के साथ संयोजन में संभावना जावा में बहुत आसान नहीं है।

स्पष्टीकरण:

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

n->{                // Method with String as both parameter and return-type
  String r="",      //  Temp-String, starting empty
         a[];       //  Temp String-array
  for(String x:"456789~Gas Giant~15;456~Ice~10;456~Ice Giant~10;567~Gaia class~10;789~Dense Atmosphere~10;78910~Desert~25;78910~Iron~14;1011~Lava~6".split(";"))
                    //  Loop over the String-parts in the format "heats~type~probability"
    if(x.split("~")[0].contains(n))
                    //   If the heats contains the input
      r+=x+";";     //    Append this entire String-part to the temp-String `r`
  long t=0,u=0;     //  Temp numbers, both starting empty
  for(String x:(a=r.split(";")))
                    //  Loop over the temp-String parts:
    t+=new Long(x.split("~")[2]);
                    //   Sum their probabilities
  t*=Math.random(); //  Get a random number in the range [0,sum_of_probabilities)
  for(String x:a)   //  Loop over the temp-String parts again
    if((u+=new Long((a=x.split("~"))[2]))>t)
                    //   The moment the current probability-sum is > the random number
      return a[1];  //    Return the Type of planet
  return"";}        //  Mandatory return we won't encounter (which returns nothing)
— केविन क्रूज़सेन
स्रोत
0

न्यूनतम , 280 277 बाइट्स

:a ' =b (("Gas Giant" 4 9 15) ("Ice" 4 6 10) ("Ice Giant" 4 6 10) ("Gaia Class" 5 7 10) ("Dense Atmosphere" 7 9 10) ("Desert" 7 10 25) ("Iron" 7 10 14) ("Lava" 10 11 6)) (=n (a n 1 get >= a n 2 get <= and) ((n 0 get b append #b) n 3 get times) when) foreach b b size random get

स्टैक पर गर्मी से शुरू होता है, स्टैक पर एक स्ट्रिंग छोड़ देता है। पायथन 2 उत्तर के रूप में समान सामान्य प्रक्रिया।

व्याख्या

ध्यान दें कि न्यूनतम समवर्ती है

:a ' =b                               ;Set the value on the stack (heat) to a, set empty quot to b
(("Gas Giant" 4 9 15) ("Ice" 4 6 10) ("Ice Giant" 4 6 10) ("Gaia Class" 5 7 10) ("Dense Atmosphere" 7 9 10) ("Desert" 7 10 25) ("Iron" 7 10 14) ("Lava" 10 11 6)) ;Data to be iterated over
(=n                                   ;  set n to current item
 (a n 1 get >= a n 2 get <= and)      ;    check if n is between the min (2nd elment of n) and max (3rd element of n) heat
 (
  (n 0 get b append #b) n 3 get times ;      insert the name(1st element of n) into the quot of names (b) a number of times corresponding to the 4th element of n
 ) when                               ;    when the previous check is true
) foreach                             ;  for every quot in previous data
b b size random get                   ;choose a random element from the list of names
— Panda0nEarth
स्रोत
0

PowerShell, 56 + 135 (CSV फ़ाइल) + 1 (फ़ाइल नाम) = 192 बाइट्स

param($z)ipcsv a|?{$z-in$_.m..$_.x}|%{,$_.p*$_.r}|Random

इसे ऑनलाइन आज़माएं! (यह थोड़ा संशोधित संस्करण है जो नीचे वर्णित अस्थायी CSV फ़ाइल बनाता है)

स्थानीय निर्देशिका में नामित CSV फ़ाइल का उपयोग ipcsv(संक्षेप में Import-CSV) aकरता है जिसमें निम्नलिखित शामिल हैं:

P,m,x,r
Gas Giant,4,9,15
Ice,4,6,10
Ice Giant,4,6,10
Gaia class,5,7,10
Dense Atmosphere,7,9,10
Desert,7,10,25
Iron,7,10,14
Lava,10,11,6

यह स्वचालित रूप से निम्न जैसी चीजों की एक चलने योग्य हैशटेबल बनाता है:

@{P=Gas Giant; m=4; x=9; r=15}
@{P=Ice; m=4; x=6; r=10}
...

इसके बाद हम Where-Object( ?) इन प्रविष्टियों को जहां हमारे इनपुट पूर्णांक बाहर निकलने के लिए $zहै -inरेंज $_.mके लिए $_.x(यानी, यह गर्मी रेंज में है)। हम फिर उन लोगों को एक Foreach-Objectलूप ( %) में पंप करते हैं जो उन नामों के यादृच्छिक अवसर के आधार पर नामों के तारों की एक सरणी बनाता है। उदाहरण के लिए, यह 15 "Gas Giant"अगर गर्मी से मेल खाता है , तो यह एक सरणी बना देगा । हम फिर उन लोगों को डालते हैं Get-Randomजो उचित भार के साथ उपयुक्त स्ट्रिंग को बाहर निकाल देंगे।

— AdmBorkBork
स्रोत
-1

PHP , 1236 बाइट्स

<?php
$heat = (int)fgets(STDIN);
$planets =
    [
        'Gas Giant' =>        ['heat_min' => 4, 'heat_max' => 9, 'selection_chance' => 15],
        'Ice' =>              ['heat_min' => 4, 'heat_max' => 6, 'selection_chance' => 10],
        'Ice Giant' =>        ['heat_min' => 4, 'heat_max' => 6, 'selection_chance' => 10],
        'Gaia class' =>       ['heat_min' => 5, 'heat_max' => 7, 'selection_chance' => 10],
        'Dense Atmosphere' => ['heat_min' => 7, 'heat_max' => 9, 'selection_chance' => 10],
        'Desert' =>           ['heat_min' => 7, 'heat_max' => 10, 'selection_chance' => 25],
        'Iron' =>             ['heat_min' => 7, 'heat_max' => 10, 'selection_chance' => 14],
        'Lava' =>             ['heat_min' => 10, 'heat_max' => 11, 'selection_chance' => 6],
    ];
foreach ($planets as $planet) {
    $chance_sum += ($heat >= $planet['heat_min'] && $heat <= $planet['heat_max']) * $planet['selection_chance'];
}
while (true) {
    foreach ($planets as $name => $planet) {
        $prob = 100 * ($heat >= $planet['heat_min'] && $heat <= $planet['heat_max']) * $planet['selection_chance'] / $chance_sum;
        if (rand(0, 100) < $prob) {
            echo $name."\n";
            exit;
        }
    }
}
?>

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

— अग्निअस वसीलियास्कस
स्रोत
5
कोड-गोल्फ प्रश्न के उत्तर के लिए उन्हें गोल्फ में प्रयास दिखाने की आवश्यकता है। व्हॉट्सएप को हटाकर आप इसे बहुत छोटा कर सकते हैं । अगला चरण एकल वर्ण नामों के लिए चर नामों को छोटा करना होगा।
— 20
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.