Czy istnieje sposób, aby uczynić to, jeśli instrukcja jest krótsza? lub łatwiejsze do utrzymania?

Question

Zrobiłem aplikację (kamień, papier, nożyczki) do celów edukacyjnych, czy jest jakiś sposób na skrócenie tego czasu?

Jest to szybki fragment kodu:

var playerSelection = "" // possible values are r,p,s 
var cpuSelection = "" // possible values are r,p,s 
var resultString = "" 

// DECIDE PLAYER RESULT 
if(playerSelection == "r") 
{ 
    if(cpuSelection == "r") 
    { 
     resultString = "draw" 
    } 
    else if(cpuSelection == "p") 
    { 
     resultString = "lose" 
    } 
    else if(cpuSelection == "s") 
    { 
     resultString = "win" 
    } 
} 
else if(playerSelection == "p") 
{ 
    if(cpuSelection == "r") 
    { 
     resultString = "win" 
    } 
    else if(cpuSelection == "p") 
    { 
     resultString = "draw" 
    } 
    else if(cpuSelection == "s") 
    { 
     resultString = "lose" 
    } 
} 
else if(playerSelection == "s") 
{ 
    if(cpuSelection == "r") 
    { 
     resultString = "lose" 
    } 
    else if(cpuSelection == "p") 
    { 
     resultString = "win" 
    } 
    else if(cpuSelection == "s") 
    { 
     resultString = "draw" 
    } 
} 

o ile mi wiadomo, jest to najprostsza forma kształcić studentów, jak to zrobić, masz jakieś pomysły?

Thanks a lot

Answer 1

Try zagnieżdżonego operatora Trójka to sprawdzić w jednej linii przy użyciu kodu poniżej

resultString = (playerSelection == "r") ? (cpuSelection == "r" ? "draw" : (cpuSelection == "p") ? "lose" : "win") : (((playerSelection == "p") ? (cpuSelection == "r" ? "win" : ((cpuSelection == "p") ? "draw" : "lose")):((cpuSelection == "r" ? "lose" : ((cpuSelection == "p") ? "win" : "draw"))))) 

można użyć enum i logiki obiegową tablicy.

Proszę sprawdzić poniższy kod.

enum GameResult : Int { 
    case None = 0 
    case Win = 1 
    case Draw = 2 
    case Lose = 3 
} 

enum Selection : Int{ 

    case Paper = 1 
    case Rock = 2 
    case Scissor = 3 
} 

var pSelect = Selection.Paper; 
var cSelect = Selection.Rock; 
var result = GameResult.None 

var playerRotation = (pSelect.rawValue) % 3 + 1; 

if(pSelect.rawValue == cSelect.rawValue){ 
    result = GameResult.Draw 
} 
else if(playerRotation == cSelect.rawValue){ 
    result = GameResult.Win 
} 
else{ 
    result = GameResult.Lose 
} 

Answer 2

Co o:

if (playerSelection == "r" && cpuSelection == "r") || (playerSelection == "p" && cpuSelection == "p") || (playerSelection == "s" && cpuSelection == "s") { 
    resultString = "draw" 
} else if (playerSelection == "r" && cpuSelection == "p") || (playerSelection == "p" && cpuSelection == "s") || (playerSelection == "s" && cpuSelection == "r") { 
    resultString = "lose" 
} else { 
    resultString = "win" 
} 

// edytowany, sugerowanej przez @Quince:

if (playerSelection == cpuSelection) { 
     resultString = "draw" 
    } else if (playerSelection == "r" && cpuSelection == "p") || (playerSelection == "p" && cpuSelection == "s") || (playerSelection == "s" && cpuSelection == "r") { 
     resultString = "lose" 
    } else { 
     resultString = "win" 
    } 

Answer 3

Należy naprawdę używać wyliczeń zarządzać wartości danych. Masz 3 możliwości, ale pracujesz z jawnymi literałami ciągów. Wyliczenia również promują instrukcje przełączania spraw, które będą wyraźniejsze w twoim przypadku.

Ponieważ masz stały zestaw opcji, nie musisz też sprawdzać każdego z nich - jeśli pierwsze 2 nie są prawdziwe, to musi być trzeci. Możesz więc założyć, że to wygrana i test na przegraną lub remis.

Answer 4

let winArray = ["rs", "pr", "sp"] 

func getResult(playerSelection:String, cpuSelection:String) -> String { 
    if playerSelection == cpuSelection { 
     return "draw" 
    } 
    if winArray.contains(playerSelection + cpuSelection) { 
     return "win" 
    } else { 
     return "lose" 
    } 
} 
resultString = getResult(playerSelection, cpuSelection) 

Korzystanie teksty stałe dla bezpieczeństwa:

enum GameResult { 
    case Win 
    case Draw 
    case Lose 
} 

enum Selection { 
    case Rock 
    case Paper 
    case Scissor 
} 

let winArray:[(Selection, Selection)] = [(.Rock, .Paper), (.Paper, .Scissor), (.Scissor, .Paper)] 

func getResult(playerSelection:Selection, cpuSelection:Selection) -> GameResult { 
    if playerSelection == cpuSelection { 
     return .Draw 
    } 
    if winArray.contains({$0.0 == playerSelection && $0.1 == cpuSelection}) { 
     return .Win 
    } else { 
     return .Lose 
    } 
} 
let playerSelection:Selection = .Rock 
let cpuSelection:Selection = .Scissor 
let gameResult = getResult(playerSelection, cpuSelection: cpuSelection) 

Answer 5

Co o tym:

let scores = ["s", "r", "p"] 
let playerScore = scores.indexOf(playerSelection)! 
let cpuScore = scores.indexOf(cpuSelection)! 
resultString = playerScore > cpuScore ? "win" : playerScore == cpuScore ? "draw" : "lose" 

A w tym konkretnym kontekście (bardzo trudne):

resultString = playerSelection < cpuSelection ? "win" : playerSelection == cpuSelection ? "draw" : "lose"