एक Numpad के आसपास संभावनाएं उत्पन्न करें

Question

आज इस प्रश्न से प्रेरित होकर , मैं उन दिलचस्प तरीकों को देखना चाहूंगा, जो विभिन्न प्रोग्रामिंग भाषाएं एक सुन्नता को संभावनाओं में बदल सकती हैं। आमतौर पर, टाइल-आधारित गेम आपको किसी भी दिशा में स्थानांतरित करने के लिए एक संख्यात्मक उपयोग करने की अनुमति देगा, जहां आपका चरित्र वर्तमान में है। इन खेलों के लिए एआई बनाते समय, Math.random() * 8यह पर्याप्त नहीं है, इसलिए मुझे आंदोलन को देखने और कुछ स्वाभाविक महसूस करने के लिए थोड़ा रचनात्मक होना पड़ा।

एक numpad इस तरह के रूप में परिभाषित किया गया है:

7 | 8 | 9
- - - - -
4 | x | 6
- - - - -
1 | 2 | 3

कृपया ध्यान दें, 5 एक अमान्य संख्या है, क्योंकि आप अपने आप को स्थानांतरित नहीं कर सकते।

सभी उदाहरण इन संभावनाओं का उपयोग करेंगे: [50, 40, 30, 20, 10]

अगर मैं चारों ओर संभावनाएं उत्पन्न करना चाहता था 8, तो यह इस तरह दिखेगा:

40 | 50 | 40 
-- | -- | --
30 | xx | 30
-- | -- | --
20 | 10 | 20

आउटपुट [20, 10, 20, 30, 30, 40, 50, 40](5 लोप के साथ) या [20, 10, 20, 30, null, 30, 40, 50, 40](5 वर्तमान के साथ) होगा

अगर मैं उन्हें चारों ओर उत्पन्न करना चाहता था 1, तो यह इस तरह दिखेगा:

30 | 20 | 10
-- | -- | --
40 | xx | 20
-- | -- | --
50 | 40 | 30

आउटपुट [50, 40, 30, 40, 20, 30, 20, 10](5 लोप के साथ) या [50, 40, 30, 40, null, 20, 30, 20, 10](5 वर्तमान के साथ) होगा

आप एक पूर्ण प्रोग्राम लिख सकते हैं जो किसी भी तरह से इनपुट लेता है (कमांड लाइन, स्टडिन) और आउटपुट प्रिंट करता है, या आप एक नंबर तर्क के साथ एक फ़ंक्शन लिख सकते हैं, जो आउटपुट प्रिंट या रिटर्न करता है। आपके प्रोग्राम या फ़ंक्शन को एक नंबर स्वीकार करना चाहिए - चारों ओर उत्पन्न करने की स्थिति। आपको इन संभावनाओं का उपयोग करना चाहिए: [50, 40, 30, 20, 10](उन्हें हार्डकोड करने की आवश्यकता नहीं है)।

बाइट्स में सबसे छोटा कोड जीतता है। मानक खामियों को अस्वीकार कर दिया जाता है। लिंक किए गए थ्रेड में पोस्ट किए गए उत्तर अस्वीकृत हैं। ट्रेलिंग या अग्रणी स्थानों की अनुमति है। आप 4अपनी पसंद के आधार पर स्थिति को अनुपस्थित या खाली मान सकते हैं। मैं आउटपुट फॉर्मेट पर बहुत ज्यादा पसंद नहीं कर रहा हूं - इसे कॉमा से अलग किए गए स्ट्रिंग्स के रूप में या एक ऐरे के रूप में प्रिंट करें।

(यह मेरा पहला सवाल है, मुझ पर आसान हो जाओ!)

Answer 1

सीजेएम, 27 बाइट्स

12369874s_$\_r#m<f{#4-z)0S}

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

विचार

यदि हम वामावर्त रूप से 5 के आसपास के अंकों से गुजरते हैं , तो हम स्ट्रिंग 12369874या इसके किसी भी घुमाव (शुरुआत के आधार पर) को प्राप्त करते हैं।

इस स्ट्रिंग को घुमाने के बाद, ताकि इनपुट अंक n सबसे बाईं ओर हो, घुमाए गए स्ट्रिंग में अंकों की निम्नलिखित संभावनाएं हैं:

50 40 30 20 10 20 30 40

यदि हम इन अंकों के सूचकांक पर विचार करते हैं, जो हैं

 0  1  2  3  4  5  6  7

उपज से प्रत्येक में 4 घटाएं

-4 -3 -2 -1  0  1  2  3

और प्राप्त करने के लिए पूर्ण मान लें

 4  3  2  1  0  1  2  3

हमें केवल 1 जोड़ना है और वांछित संभावनाओं को प्राप्त करने के लिए 0 को जोड़ना है ।

कोड

12369874s                   e# Push "12369874".
         _$                 e# Push a sorted copy, i.e., "12346789".
           \                e# Swap it with the unsorted original.
            _r#             e# Find the index of the input in an unsorted copy.
               m<           e# Rotate the unsorted original that many units left.
                 f{       } e# For each character C in "12346789":
                            e#   Push the rotated string.
                   #        e#   Find the index of C.
                    4-      e#   Subtract 4.
                      z     e#   Compute the absolute value.
                       )    e#   Add 1.
                        0S  e#   Push a 0 and a space.

Answer 2

प्रोलॉग, 166 बाइट्स

a(A,R):-I:J:K:L:M=50:40:30:20:10,B is abs(5-A),member(B:S,[4:[I,J,K,J,L,K,L,M],3:[J,I,J,K,K,L,M,L],2:[K,J,I,L,J,M,L,K],1:[J,K,L,I,M,J,K,L]]),(A/5>1,reverse(S,R);S=R).

यह इस तथ्य का उपयोग करता है कि 9 के लिए परिणाम 1 के लिए परिणाम का उल्टा है, वही 2 और 8, 3 और 7 और 4 के लिए और 6. 6 के परिणाम के लिए 1 के परिणाम से जाने के लिए पहचानने योग्य पैटर्न हैं। और 4, लेकिन मुझे पूरा यकीन है कि इसे 1 से 4 के सीक्वेंस को हार्डकोड करने से ज्यादा लंबा करना होगा, जो कि मैंने किया।

उदाहरण: a(7,R).आउटपुट R = [30, 20, 10, 40, 20, 50, 40, 30]।

Comments

एक वैध रणनीति, हालांकि मुझे उम्मीद है कि कुछ भाषाओं को एल्गोरिदम को करना आसान होगा, जितना कि इसे हार्डकोड करना होगा। मुझे लगता है हम देखेंगे।

— सियारिया

@ सियारिया मुझे लगता है कि सरणी-उन्मुख भाषाएं ऐसा ही करेंगी। आप दुर्भाग्य से आमतौर पर सूची के तत्वों को प्रोलॉग में कम मात्रा में बाइट्स की अनुमति नहीं दे सकते।

— 22:18

Answer 3

अजगर - 115

a=[50,40,30,20,10,20,30,40]
b=[0,1,2,7,8,3,6,5,4]
def v(n):
 c=8-b[n-1]
 return[(a[c:]+a[:c])[e]for e in b if e-8]

aसंख्या के चारों ओर मानों के साथ एक सरणी है (1 से काउंटर-क्लॉकवाइज), और bइसके आसपास के पदों के लिए नंबरपैड पर नक्शे की संख्या। इनपुट नंबर के लिए अंकपैड के चारों ओर रिक्त स्थान की संख्या के आधार पर ( bइसका उपयोग करके निर्धारित किया जाता है ), यह एक सरणी बनाता है जिसके साथ कई तत्व सामने से aअंत तक चले गए , फिर bतत्वों का फिर से उपयोग करके नंबरपैड के साथ मेल खाने के लिए फिर से व्यवस्थित करें।

Comments

आप अपने लूप में /10एक बनाकर और फिर बहुत कुछ बचा सकते हैं *10।

— माल्टीसेन

क्या यह (a[c:]+a[:c])[e]वही नहीं है a[(c+e)%8]या है a[c+e-8]? और फिर cअभिव्यक्ति को सरल बनाने में प्लगिंग ।

— xnor

Answer 4

पायथ - 38 बाइट्स

दो सरणियों के लिए आधार संपीड़न के अलावा पायथन उत्तर के समान तकनीक का उपयोग करता है।

J_jC"3ê"T*RTm@.<jC"<àR"[e-mail]4

इसे यहाँ ऑनलाइन प्रयास करें ।

Comments

Ê और à क्या कर रहे हैं?

— चरण

@ आधार को पूर्वोक्त आधार संपीड़न: codegolf.stackexchange.com/questions/40039/…

— माल्टीसेन

ये छोटे जवाब मुझे विस्मित करने के लिए कभी नहीं रोकेंगे।

— सियारिया

@ सियारिया मैं वास्तव में अजगर को सीखने का सुझाव दे सकता हूं - ये कार्यक्रम उनकी तुलना में बहुत अधिक जटिल हैं :)

— orlp

Answer 5

जावा, 190

void g(int n){int i[]={8,0,1,2,7,8,3,6,5,4};String v="54321234",s="";n=i[n];if(n>0)v=v.substring(8-n)+v.substring(0,8-n);for(n=0;n++<9;s=", ")if(n!=5)System.out.print(s+v.charAt(i[n])+"0");}

String v इनपुट में 1 = डिफ़ॉल्ट 50 होने के साथ countrclockwise क्रम में संभाव्यता (10 से विभाजित) रखती है।

int[]iइनपुट को v में एक इंडेक्स में अनुवाद करता है। उदाहरण के लिए, v.charAt(i[1])है 5। इनपुट 0 और 5 अमान्य हैं, इसलिए i [0] और i [5] दोनों का प्लेसहोल्डर मान 8 है जो v के अंत में '\ 0' के लिए सूचकांक है।

मैं संख्या में v के दाईं ओर i [n] द्वारा घुमाता हूं, और फिर संभावनाओं को अल्पविराम द्वारा अलग किए गए स्ट्रिंग्स के रूप में प्रिंट करता हूं।