आईएफ कथन के बहुत से विकल्प के लिए बेहतर विकल्प? मानों की तालिका

Question

मेरे पास चाल की एक तालिका है जो यह तय करती है कि खिलाड़ी एआई के खिलाफ उनके चयन के आधार पर जीतता है या नहीं। बहुत अधिक चाल के साथ रॉक, पेपर, कैंची सोचो। मैं अंततः इसे पायथन में कोडिंग कर दूंगा, लेकिन शुरू होने से पहले, मैं जानना चाहता हूं कि क्या एलओटीएस और आईओटी स्टेटमेंट्स के बजाय ऐसा करने का बेहतर तरीका है?

तालिका इस प्रकार है:

मैं सोच रहा हूँ कि चाल नंबर, या ऐसा ही कुछ सौंपा जा करने की आवश्यकता होगी? मुझे नहीं पता कि कहां से शुरू करना है ...

Answer 1

आप एक नियम का उपयोग कर सकते हैं? कुछ इस तरह:

#dict of winning outcomes, the first layer represents the AI moves, and the inner 
#layer represent the player move and the outcome 
ai = { 
    'punch' : { 
     'punch' : 'tie', 
     'kick' : 'wins', 
    }, 
    'stab' : { 
     'punch' : 'loses', 
     'kick' : 'loses' 
    } 
} 

ai_move = 'punch' 
player_move = 'kick' 
print ai[ai_move][player_move] #output: wins 


ai_move = 'stab' 
player_move = 'punch' 
print ai[ai_move][player_move] #output: loses 

मैं सभी चालों नक्शा नहीं था, लेकिन आप सार मिलता है

Answer 2

हाँ, के रूप में सभी संभव संयोजनों के साथ एक शब्दकोश में कुंजी/मान जोड़े के रूप में निर्णय की दुकान परिणाम के रूप में कुंजी और निर्णय। मूल रूप से संभावित चाल के लिए एक लुकअप टेबल बनाते हैं।

यह सभी संभावित संयोजनों को स्टोर करने के खर्च पर निर्णय लेने की गति बढ़ाता है।

def tie(): 
    print("It's a tie!") 

def lose(): 
    print("You lose") 

def win(): 
    print("You win") 
moves = { 
    # player_ai action 
    'punch_punch': tie, 
    'punch_kick': lose, 
    'punch_stab': lose, 
    <..> 
} 
player_move = <move> 
ai_move = <move> 
key = "_".join([player_move, ai_move]) 
if key in moves: 
    # Execute appropriate function 
    return moves[key]() 
raise Exception("Invalid move") 

Answer 3

आप शब्दकोशों का एक शब्दकोश (नेस्टेड शब्दकोश) का प्रयास कर सकते हैं। पठनीयता में सुधार के लिए संख्याओं के मानचित्र के बजाय, टेक्स्ट फॉर्म में मूल्यों और कुंजियों को रखें।

outcome = {} 
outcome['punch'] = {} 
outcome['punch']['punch'] = 'Tie' 
outcome['punch']['kick'] = 'Lose' 
... 
outcome['kick'] = {} 
outcome['kick']['punch'] = 'Win' 
outcome['kick']['kick'] = 'Tie' 
... 
i_do = 'punch' 
he_does = 'fling' 
... 
if outcome[i_do][he_does] == 'Win': 
    print("Woohoo!") 

Answer 4

आप नंबरों के लिए ले जाता है मैप करने के लिए एक अजगर शब्दकोश इस्तेमाल कर सकते हैं:

move = {'Punch': 0, 'Kick': 1} 

और फिर परिणाम का निर्धारण करने के लिए एक मैट्रिक्स का उपयोग करें। उस

import numpy 
move = {'Punch': 0, 'Kick': 1} 

outcome = numpy.matrix([['Tie','Loses'],['Wins','Tie']]) 


# Punch vs Punch => Tie 
print outcome[move['Punch'], move['Punch']] 

# Punch vs Kick => Punch loses 
print outcome[move['Punch'], move['Kick']] 

Answer 5

के लिए Numpy का उपयोग किया जा सकता है, मैं इसके लिए 2-आयामी सूची का उपयोग करूंगा। प्रत्येक हमले को इंडेक्स 0 से 5 तक डीकोड किया जाता है और टाई जीत जाती है और हानि 1, 0 और -1 के रूप में डीकोड की जाती है।

तो सूची कुछ इस तरह दिखेगा (अपने उदाहरण के आधार पर नहीं, मैं सिर्फ कुछ यादृच्छिक संख्या डाल):

table = [[1,0,-1,0,1,-1],[1,1,0,1,0,-1],...,etc.] 

और आप इसे इस तरह से पुनः प्राप्त करेगा: आप

table[0][1] 

Answer 6

इस

map = [ 
    [0,-1,-1,1,1,-1], 
    [1,0,-1,-1,1,-1], 
    [1,1,0,-1,-1,1], 
    [-1,1,1,0,-1,1], 
    [-1,-1,1,1,0,-1], 
    [1,1,-1,-1,1,0] 
] 

यहाँ की तरह ऊपर अपनी तालिका में इस प्रकार के हमलों का एक नक्शा बना सकते हैं, 0 एक ड्रॉ, 1 एक जीत है और -1 एक नुकसान है।

अब हमलों की एक सरणी बनाएं जहां हमलों के स्थान उपरोक्त मानचित्र से मेल खाते हैं।

attacks = ["Punch", "Kick", "Stab", "Throw", "Fling", "Uppercut"] 

अब आप आसानी से पता लगा सकते हैं एक हमले धड़कता है एक और

map[attacks.index("Stab")][attacks.index("Punch")] 

>>> 1 

वार पंच से अधिक जीतता