PG0002.Question02

[jack81722]

Introduction

聖哉在後來的冒險過程中發現這世界的怪物可能會有屬性，屬性被分成火、水、風，其中水剋火、火剋風、風剋水，使用正確的屬性戰鬥時，能力值可被視為兩倍，其他情況一倍；聖哉擁有特殊的全屬性體質，但一天只能用一種屬性並且每天會變化，為了保證獲勝，聖哉一天只打一次戰鬥，每天的屬性以elementals表示，怪物的屬性以monsterElementals表示，跟之前一樣，寫出一函式判斷聖哉能否贏得勝利？

Answer

解答

跟第一題相比，這題的思路略為複雜一點，需要多判斷屬性的相剋，其他的作法與第一題大同小異。

bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
{
    for (int i = 0; i < elementals.Length; i++)
    {
        if (status * Double(elementals[i], monsterElementals[i]) < monsters[i] * Double(monsterElementals[i], elementals[i]))
        {
            return false;
        }
        status += monsters[i];
    }
    return true;
}

int Double(EElemental attacker, EElemental opposite)
{
    if ((attacker == EElemental.Fire && opposite == EElemental.Wind) ||
        (attacker == EElemental.Water && opposite == EElemental.Fire) ||
        (attacker == EElemental.Wind && opposite == EElemental.Water))
    {
        return 2;
    }
    return 1;
}

[A24575255]

JIA（程式新手）

我的答案

public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
{
    int currentStatus = status;
    int selfDamageBonus = 1;
    int monsterDamageBonus = 1;
    int length = monsters.Length;
    for (int i = 0; i < length; i++)
    {
        selfDamageBonus = DamageBonus(elementals[i], monsterElementals[i]);
        monsterDamageBonus = DamageBonus(monsterElementals[i], elementals[i]);
        if (currentStatus * selfDamageBonus < monsters[i] * monsterDamageBonus)
            return false;
        currentStatus += monsters[i];
    }
    return true;
}

public int DamageBonus(EElemental elemental, EElemental monsterElemental)
{
    if ((elemental == EElemental.Fire && monsterElemental == EElemental.Wind) ||
        (elemental == EElemental.Water && monsterElemental == EElemental.Fire) ||
        (elemental == EElemental.Wind && monsterElemental == EElemental.Water))
        return 2;
    return 1;
}

[vre343434]

七七(程式)

我的答案

        public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
        {
            for (int i = 0; i < elementals.Length; i++)
            {
                if (
                    status * AttributeRestraint(elementals[i], monsterElementals[i])
                    < monsters[i] * AttributeRestraint(monsterElementals[i], elementals[i])
                )
                {
                    return false;
                }
                status += monsters[i];
            }
            return true;
        }

        int AttributeRestraint(EElemental attacker, EElemental victim)
        {
            if ((attacker == EElemental.Fire && victim == EElemental.Wind)
                || (attacker == EElemental.Water && victim == EElemental.Fire)
                || (attacker == EElemental.Wind && victim == EElemental.Water))
            {
                return 2;
            }
            return 1;
        }
    

[YouSyuan]

Syuan(新人)

我的答案

public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
        {
            for (int i = 0; i < monsters.Length; i++)
            {
                int statusDamageBonus = AttackDouble(elementals[i], monsterElementals[i]);
                int monsterDamageBonus = AttackDouble(monsterElementals[i], elementals[i]);
                if (status * statusDamageBonus < monsters[i] * monsterDamageBonus)
                    return false;
                status += monsters[i];
            }
            return true;
        }

        public int AttackDouble(EElemental elemental, EElemental monsterElemental)
        {
            if ((elemental == EElemental.Fire && monsterElemental == EElemental.Wind) ||
                (elemental == EElemental.Water && monsterElemental == EElemental.Fire) ||
                (elemental == EElemental.Wind && monsterElemental == EElemental.Water))
                return 2;
            return 1;
        }

[keithku]

Lemon(企劃&程式)

我的答案

[louise-bwsx]

小4(企劃,美術,程式,音樂,新人)

Details

        public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
        {
            for (int i = 0; i < monsters.Length; i++)
            {
                int changeStatus = ElementCrit(elementals[i], monsterElementals[i]) ? status * 2 : status;
                int changeMonsters = ElementCrit(monsterElementals[i], elementals[i]) ? monsters[i] * 2 : monsters[i];
                Debug.Log("changeStatus" + changeStatus);
                Debug.Log("changeMonsters" + changeMonsters);
                if (changeStatus >= changeMonsters)
                {
                    status += monsters[i];
                    continue;
                }
                return false;
            }
            return true;
        }

        public bool ElementCrit(EElemental elemental1, EElemental elemental2)
        {
            if ((elemental1 == EElemental.Fire && elemental2 == EElemental.Wind) ||
                (elemental1 == EElemental.Water && elemental2 == EElemental.Fire) ||
                (elemental1 == EElemental.Wind && elemental2 == EElemental.Water))
            {
                return true;
            }
            return false;
        }

[OLDShaw1022]

老蕭OLDShaw（程式）

我的答案

        public bool CanWin(int status, EElemental[] myElementals, int[] monsters, EElemental[] monsterElementals)
        {
            for (int i = 0; i < myElementals.Length; i++)
            {
                int myFinalStatus = GetFinalStatus(status, myElementals[i], monsterElementals[i]);
                int monsterFinalStatus = GetFinalStatus(monsters[i], monsterElementals[i], myElementals[i]);

                if (myFinalStatus < monsterFinalStatus) return false;

                status += monsters[i];
            }
            return true;
        }

        int GetFinalStatus(int status, EElemental myElement, EElemental opponenetElement)
        {
            int finalStatus = status * ElementMultiplier(myElement, opponenetElement);
            return finalStatus;
        }

        int ElementMultiplier(EElemental myElement, EElemental opponentElement)
        {
            int strong = 2;
            int normal = 1;
            switch (myElement)
            {                
                case EElemental.Fire:
                    if (opponentElement == EElemental.Wind) return strong;
                    break;
                case EElemental.Water:
                    if (opponentElement == EElemental.Fire) return strong;
                    break;
                case EElemental.Wind:
                    if (opponentElement == EElemental.Water) return strong;
                    break;
            }
            return normal;
        }

測試截圖

想不到要怎樣讓這判斷式變好看。

[jack81722]

能不能一次就看出要表達的邏輯是可讀性的指標之一
再來就是減少判斷式的量也會讓其他人比較容易閱讀
我個人對switch的用法是盡量不讓每個case裡面再作判斷或是裡面有超過三行的邏輯(如果有，就盡量用func處理)
比較常見的處理可以是

if (條件1) return 結果1;
if (條件2) return 結果2;
// ...以此類推

每個條件越減短越好，如果重複性不高或是多種case的結果一樣的時候
也都盡量以func處理去包裝你的邏輯，可以的話好的命名能更好的幫助閱讀

[A24575255]

這樣判斷或許會好看點

程式碼

public int ElementMultiplier(EElemental attacker, EElemental defender)
{
    Dictionary<EElemental, EElemental> counterTable = new Dictionary<EElemental, EElemental>()
    {
          {EElemental.Water, EElemental.Fire},
          {EElemental.Fire,  EElemental.Wind},
          {EElemental.Wind, EElemental.Water},
    };
    bool isCounter = counterTable.ContainsKey(attacker) && counterTable[attacker] == defender;
    return isCounter ? 2 : 1;
}

[jack81722]

這作法很不錯

[SoonYu97]

小鲨 (程式)

答案

public class Question2
{
    public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
    {
        for (int i = 0; i < elementals.Length; i++)
        {
            int monster = monsters[i];
            if (status * ElementalBuff(elementals[i], monsterElementals[i]) >= monster * ElementalBuff(monsterElementals[i], elementals[i]))
                status += monster;
            else
               return false;
        }
        return true;
    }

private int ElementalBuff(EElemental elemental, EElemental monsterElemental)
{
  if (elemental == EElemental.Water && monsterElemental == EElemental.Fire)
    return 2;
  if (elemental == EElemental.Fire && monsterElemental == EElemental.Wind)
    return 2;
  if (elemental == EElemental.Wind && monsterElemental == EElemental.Water)
    return 2;

  return 1;
}

[XZKpo666]

K者賢(遊戲設計)

我的解答與感想

public class Question2
    {
        public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
        {
            for (int i = 0; i < monsters.Length; i++)
            {
                if (monsters[i] * CanRestraint(monsterElementals[i], (elementals[i])) > 
                    status * CanRestraint(elementals[i], monsterElementals[i])) return false;
                status += monsters[i];
            }
            return true;
        }
        int CanRestraint(EElemental Atk, EElemental Def)
        {
            if (Atk == EElemental.Water && Def == EElemental.Fire ||
                Atk == EElemental.Fire && Def == EElemental.Wind  ||
                Atk == EElemental.Wind && Def == EElemental.Water) return 2;
            return 1;
        }
    }

感想：這一題是真的難 一開始雖然有頭緒 知道大概邏輯 卻不知道該如何表達 後面是看一眼解答 然後迅速關上 讓自己去理解 並嘗試再自己寫出來 最後才成功寫出來

[jack81722]

這樣也很好，程式碼的組合非常多變
思路有時比技術重要，技術是支撐你解決辦法的手段
而思路是你解決辦法的想法，每個人的做法都不一樣
多看看其他人的做法也是不錯的進步方式，共勉之

[chopin890612]

阿邦(企劃)

我的答案

public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
{
    for(int i = 0; i < monsters.Length; i++)
    {
        if (monsters[i] * EleMutiplyer(monsterElementals[i], elementals[i]) > status * EleMutiplyer(elementals[i], monsterElementals[i]))
            return false;
        else
            status += monsters[i];
    }
    return true;
}
private int EleMutiplyer(EElemental myEle, EElemental yourEle)
{
    switch (myEle)
    {
        case EElemental.Fire:
            if (yourEle == EElemental.Wind)
                return 2;
            break;
        case EElemental.Water:
            if (yourEle == EElemental.Fire)
                return 2;
            break;
        case EElemental.Wind:
            if (yourEle == EElemental.Water)
                return 2;
            break;
        default:
            break;
    }
    return 1;
}

慢慢複習中~~

[jack81722]

參考我的回覆
#4 (reply in thread)

[cowbear6598]

CptSoap (程式)

我的答案

public class Question2
{
    private int currentStatus;

    public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
    {
        currentStatus = status;

        if (monsters.Length != monsterElementals.Length)
        {
            throw new Exception("怪物屬性與怪物數值長度不正確");
        }

        if (monsters.Length != elementals.Length)
        {
            throw new Exception("玩家屬性與怪物數值長度不正確");
        }

        for (var i = 0; i < monsters.Length; i++)
        {
            var playerDamageMultiply  = GetElementalMultiply(elementals[i], monsterElementals[i]);
            var monsterDamageMultiply = GetElementalMultiply(monsterElementals[i], elementals[i]);

            if (currentStatus * playerDamageMultiply < monsters[i] * monsterDamageMultiply)
                return false;

            currentStatus += monsters[i];
        }

        return true;
    }

    private static int GetElementalMultiply(EElemental myElemental, EElemental oppositeElemental)
    {
        // 克制屬性
        if (myElemental == EElemental.Fire  && oppositeElemental == EElemental.Wind ||
            myElemental == EElemental.Water && oppositeElemental == EElemental.Fire ||
            myElemental == EElemental.Wind  && oppositeElemental == EElemental.Water)
            return 2;

        return 1;
    }
}

[jack81722]

如果你要回傳Exception的話可以用InvalidArgumentExcetion
將來下游邏輯要用try-catch處理的時候也會比較好辨識什麼例外狀況要用什麼邏輯處理

[BolingCan]

罐頭（新人）

我的答案ヾ(•ω•`)o

public class Question2
    {
        public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
        {
            for (int i = 0; i < monsters.Length; i++)
            {
                if (status * CheckCrit(elementals[i], monsterElementals[i]) <
                    monsters[i] * CheckCrit(monsterElementals[i], elementals[i]))
                    return false;
                status += monsters[i];
            }

            return true;
        }

        private int CheckCrit(EElemental atk, EElemental def)
        {
            if (atk == EElemental.Water && def == EElemental.Fire ||
                atk == EElemental.Fire && def == EElemental.Wind ||
                atk == EElemental.Wind && def == EElemental.Water)
                return 2;
            return 1;
        }
    }

恩~寫完後有點期待勇者聖哉的冒險故事後續~感覺可以出輕小說(?)(❤´艸｀❤)

[jack81722]

已經有這部輕小說作品了喔，還有動畫化
這題是借用那個世界觀，讓題目比較沒那麼枯燥
可以去查《這個勇者明明超TUEEE卻過度謹慎》

[Suncacao]

Suncacao(程式)

我的答案

public class Question2
    {
        public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
        {
            //check input
            if(StatusLimiter(status)){
                Debug.LogError("Sorry,your status can't over 10M!check pls.");
                return false;       
            }

            if(monsters.Length <1 ||monsters.Length >1000){
                Debug.LogError("Sorry,monsters data wrong!check pls.");
                return false;       
            }

            if(monsters.Length <1 ||monsters.Length >1000){
                Debug.LogError("Sorry,monsters data wrong!check pls.");
                return false;       
            }

            int index = 0;
            while(index<monsters.Length){
                if(StatusLimiter(monsters[index])){
                    Debug.LogError("Sorry,your monsters index " + index + " can't over 10M!check pls.");
                    return false;
                }
                index +=1;
            }

            if(monsters.Length > elementals.Length){
                Debug.LogError(elementals.Length + "wave,your Elementals are empty.");
            }

            if(monsters.Length > monsterElementals.Length){
                Debug.LogError(elementals.Length + "wave,monster Elementals are empty.");
            }
            //Okay! Game Start
            index = 0;
            while(index < monsters.Length){
                EElemental playerElementals = EElemental.None;
                EElemental opponentElementals = EElemental.None;
                if(index < elementals.Length){
                    playerElementals = elementals[index];
                }

                if(index < monsterElementals.Length){
                    opponentElementals = monsterElementals[index];
                }

                if(FightVictor(status,playerElementals,monsters[index],opponentElementals)){
                    status += monsters[index];
                }else{
                    return false;
                }

                index +=1;
            }

            return true;
        }
        
        private bool StatusLimiter(int status){
            if(status <0 ||status >10000000){
                return true;       
            }
            return false;
        }

        private bool FightVictor(int status,EElemental elementals,int monsterStatus,EElemental monsterElementals){
            float bouns = 1f;
            if((elementals == EElemental.Fire && monsterElementals == EElemental.Wind) || (elementals == EElemental.Water && monsterElementals == EElemental.Fire) || (elementals == EElemental.Wind && monsterElementals == EElemental.Water)){
                bouns = 2f;
            }else if((elementals == EElemental.Fire && monsterElementals == EElemental.Water) || (elementals == EElemental.Water && monsterElementals == EElemental.Wind) || (elementals == EElemental.Wind && monsterElementals == EElemental.Fire)){
                bouns = 0.5f;
            }
            
            if(status * bouns <monsterStatus){
                return false;       
            }
            return true;
        }
    }

我打完程式碼後看這裡發現屬性的處理跟其他成員差異很大
我的思路大概是FGO的職階攻擊&&防禦的攻擊補正
例如劍職打弓職補正是0.5，而狂職打劍職補正是1.5，劍職打槍職補正是2

[jack81722]

這種增益滿常見的
像世紀帝國也有對城、對步兵、對弓兵等多種加成

你的想法比較像是計算這類攻擊數值時的處理，基本也沒錯
如果情境複雜一點，我也可能會像你這樣寫
但是計算方式不只一種
就像x + y > z你也可以理解成x > z - y這樣，沒有一定

[jefflin0424]

肥羊(程式)

我的答案

public class Question2
    {
        public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
        {


            for (int i = 0; i < monsters.Length; i++)
            {
                int statusBouns = ElementalMultiplier(elementals[i], monsterElementals[i]);
                int monsterBouns = ElementalMultiplier(monsterElementals[i], elementals[i]);

                if (status * statusBouns < monsters[i] * monsterBouns) return false;

                status += monsters[i];
            }
            return true;
        }

        int ElementalMultiplier(EElemental heroElemental, EElemental monsterElemental)
        {
            if ((heroElemental == EElemental.Fire && monsterElemental == EElemental.Wind) ||
            (heroElemental == EElemental.Water && monsterElemental == EElemental.Fire) ||
            (heroElemental == EElemental.Wind && monsterElemental == EElemental.Water))
            {
                return 2;
            }
            return 1;
        }
    }

[angus945]

Angus 小呈 （企劃程式技美圖形工程師什麼的，窩都想當）

答案

        const int minValue = 0;
        const int maxValue = 10000000;
        const int maxMonster = 1000;
        public bool ElementalCheck(EElemental sealf, EElemental enemy)
        {
            switch (sealf)
            {
                case EElemental.Fire:
                    return enemy == EElemental.Wind;

                case EElemental.Water:
                    return enemy == EElemental.Fire;

                case EElemental.Wind:
                    return enemy == EElemental.Water;
            }

            return false;
        }
        public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
        {
            int battleCount = Mathf.Min(monsters.Length, maxMonster);

            for (int day = 0; day < battleCount; day++)
            {
                int battleStatus = Mathf.Clamp(status, minValue, maxValue);
                int enemyStatus = Mathf.Clamp(monsters[day], minValue, maxValue);

                battleStatus *= ElementalCheck(elementals[day], monsterElementals[day]) ? 2 : 1;
                enemyStatus *= ElementalCheck(monsterElementals[day], elementals[day]) ? 2 : 1;

                if (battleStatus >= enemyStatus)
                {
                    status += enemyStatus;
                }
                else return false;
            }

            return true;
        }

[ISnoweve]

Snoweve (程式)

我的答案

  public class Question2
  {
      public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
      {
          for (int i = 0; i < monsters.Length; i++)
          {
              if (status * CheckElementals(elementals[i], monsterElementals[i]) 
                  < monsters[i]*CheckElementals(monsterElementals[i], elementals[i])) return false;
              status += monsters[i];
          }
          return true;
      }
      public int CheckElementals(EElemental m_Atk, EElemental m_GetAtk)
      {
          if ((m_Atk == EElemental.Fire && m_GetAtk == EElemental.Wind)||
              (m_Atk == EElemental.Water && m_GetAtk == EElemental.Fire)||
              (m_Atk == EElemental.Wind && m_GetAtk == EElemental.Water))
          {
              return 2;
          }
          return 1;
      }

<<反饋>>

[crazyjimmy0623]

吉米（不知道要學什麼但是喜歡創作的新人）

答案在這

   public class Question2
    {
         public enum Function
        {
            CheckLength,
            CheckValue
        }

        private int minValue = 0;
        private int MaxValue = 10000000;
        private int MinLength = 1; 
        private int MaxLength = 1000; 

         public bool CheckValue(Function Function, int Value)
        {
            switch (Function)
            {
                case Function.CheckLength:
                    return Value >= MinLength && Value <= MaxLength;
                case Function.CheckValue:
                    return Value >= minValue && Value <= MaxValue;
                default:
                    return false;
            } 
        }

        public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
        {
            if(elementals.Length != monsters.Length ||
            monsters.Length != monsterElementals.Length ||
            monsterElementals.Length != elementals.Length) return false;

            if(!CheckValue(Function.CheckLength, elementals.Length)) return false;
            if(!CheckValue(Function.CheckValue, status)) return false;

            for (int i = 0; i < elementals.Length; i++)
            {
                if(!CheckValue(Function.CheckValue, monsters[i])) return false;

                if(status * HandleElemental(elementals[i], monsterElementals[i]) >= monsters[i] * HandleElemental(monsterElementals[i], elementals[i]))
                    status += monsters[i];       
                else
                    return false;
            }
            return true;
        }

        public int HandleElemental(EElemental MyElemental , EElemental EnemyElemental)
        {
            if((MyElemental == EElemental.Water && EnemyElemental == EElemental.Fire) ||
                (MyElemental == EElemental.Fire && EnemyElemental == EElemental.Wind) ||
                (MyElemental == EElemental.Wind && EnemyElemental == EElemental.Water))
            {
                return 2;   
            }
                   
            return 1;
        }      
    }

!!感謝老師感謝!!

[jack81722]

Oo讚嘆師父讚嘆oO

[riveRobot]

riverRobot (新人/企劃/程式)

我的答案

public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
{
	for(int i = 0; i < monsters.Length; i++)
	{
		int fixStatus = status;
		int fixMonsters = monsters[i];
		if( 
		(elementals[i] == EElemental.Fire && monsterElementals[i] == EElemental.Wind) ||
		(elementals[i] == EElemental.Wind && monsterElementals[i] == EElemental.Water) ||
		(elementals[i] == EElemental.Water && monsterElementals[i] == EElemental.Fire))
		{
			fixStatus *= 2;
		}
		else if( 
		(elementals[i] == EElemental.Wind && monsterElementals[i] == EElemental.Fire) ||
		(elementals[i] == EElemental.Water && monsterElementals[i] == EElemental.Wind) ||
		(elementals[i] == EElemental.Fire && monsterElementals[i] == EElemental.Water))
		{
			fixMonsters *= 2;
		}
		
		if ( fixStatus >= fixMonsters )
		{
			status += monsters[i];
		}
		else
		{
			return false;
		}
	}
	return true;
}

單元測試結果

課程/作業心得

不知道為甚麼就下意識地覺得所有東西要寫在同一個Function裡面，然後就寫成這樣了，大概是練習不足吧 完成後再看了老師範例後就有種理解不好看跟好看的程式差別（？）至少將功能拆分確實能大大簡化內容、也能提升理解和程式的可動性呢（自己感覺 另外也在同學的回覆中注意到自己沒有做輸入內容限制的判定，既然有給需求就應該要有限制，下次得注意

然後每堂課都要謝謝老師一次～不論是課程影片簡報、能讓自己理解須注意跟不熟的內容、還有提供的作業跟範例等等，謝謝老師～

[s32436515]

肉鬆（程式 / 音樂）

我的答案

　　 int status = 18;
        EElemental[] elementals = new EElemental[]
        {
            EElemental.Fire,
            EElemental.Wind,
            EElemental.Water
        };
        int[] monsters = new int[] { 33, 25, 150 };
        EElemental[] monsterElementals = new EElemental[]
        {
            EElemental.Wind,
            EElemental.Fire,
            EElemental.Fire
        };

        public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
        {
            for (int i = 0; i < elementals.Length; i++)
            {
                if (status * Double(elementals[i], monsterElementals[i]) < monsters[i] * Double(monsterElementals[i], elementals[i]))
                {
                    return false;
                }
                status += monsters[i];
            }
            return true;
        }

        int Double(EElemental attacker, EElemental opposite)
        {
            if ((attacker == EElemental.Fire && opposite == EElemental.Wind) ||
                (attacker == EElemental.Water && opposite == EElemental.Fire) ||
                (attacker == EElemental.Wind && opposite == EElemental.Water))
            {
                return 2;
            }
            return 1;
        }

謝謝勞師

[jane901201]

Tina( 程式 )

我的答案

namespace PG0002.Questions
{
    public class Question2
    {
        public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
        {
            int currentPlayerStatus = status;
            for (int i = 0; i < monsters.Length; i++)
            {
                int calculatePlayerStatus = currentPlayerStatus;
                int calculateMonsterStatus = monsters[i];
                
                if (IsDoubleStatus(elementals[i], monsterElementals[i]))
                    calculatePlayerStatus *= 2;
                else
                {
                    calculateMonsterStatus *= 2;
                }
                if (calculatePlayerStatus >= calculateMonsterStatus)
                {
                    currentPlayerStatus += monsters[i];
                }
                else
                    return false;
            }
            return true;
        }

        private bool IsDoubleStatus(EElemental attackUnitEElemental, EElemental beAttackedUnitEElemental)
        {
            if ((EElemental.Water == attackUnitEElemental && EElemental.Fire == beAttackedUnitEElemental)
                || (EElemental.Fire == attackUnitEElemental && EElemental.Wind == beAttackedUnitEElemental)
                || (EElemental.Wind == attackUnitEElemental && EElemental.Water == beAttackedUnitEElemental))
                return true;
            return false;
        }
    }
}

[ChiaBurn]

ChiaBurn(程式 | 企劃)

作業程式碼

    public class Question2
    {
        public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
        {
            var totalDay = elementals.Length;
            for (var i = 0; i < totalDay; i++)
            {
                var element = elementals[i];
                var monster = monsters[i];
                var monsterElement = monsterElementals[i];

                var atk = element.HasBuff(monsterElement) ? status * 2 : status;
                var monsterAtk = monsterElement.HasBuff(element) ? monster * 2 : monster;

                if (atk < monsterAtk)
                {
                    return false;
                }

                status += monster;
            }

            return true;
        }
    }

    public static class ElementalExtension
    {
        public static bool HasBuff(this EElemental self, EElemental enemy)
        {
            switch (self)
            {
                case EElemental.Fire:
                    return enemy.Equals(EElemental.Wind);

                case EElemental.Water:
                    return enemy.Equals(EElemental.Fire);

                case EElemental.Wind:
                    return enemy.Equals(EElemental.Water);

                default:
                    return false;
            }
        }
    }

程式碼測試結果

想法與反饋

1. 在判斷攻擊力是否有加成時，為了更強調「攻擊者」的主體性，我把方法抽成了靜態的extension方法，讓使用方法時呈現攻擊者.hasBuff(被攻擊者)，希望增加程式的可讀性。但這是自己在寫網站後端程式專案時的做法，好奇這樣子的靜態extension寫法對於Unity專案會不會有維護或運作上負面的影響呢？
2. 初步利用switch完成相剋判斷後，我一直在想有沒有什麼一勞永逸的演算法可以讓我不用把情境一個個列出來？我一路思考了可能的方案：利用減法差值、利用除法餘數、把Enum值設計為二進制後利用位元運算......最後甚至把腦筋動到資料結構上——我查到了一種叫「循環連結串列(circular linked list)」的結構：如果我把三元素串成一個環，只需要排除None後判斷「被攻擊者是不是我的下一個元素」就能完成判斷了！當我喜孜孜地決定要改寫程式時，忽然想到......不對！這是僅限「一物剋一物」的情境，萬一未來需求有異動、企劃要求「火除了剋風以外還要能剋冰」怎麼辦呢？萬一這程式未來交由別人維護，讀我程式的人有辦法快速地知道具體要改動的程式範圍在哪嗎？冷靜思考後，發現switch雖然囉嗦，但擴充性與可維護性似乎是目前最好的。有時最精簡漂亮、技術酷炫的寫法在實務上可能反而失去了彈性，甚至成為接手維護者的噩夢，真的是不可不慎呀！

[jack81722]

1. 基本上不會有什麼影響，很多C#內部的功能實作也都倚賴extension，雖然之後會講，不過還是可以跟你簡單講解一下：實際上你會看到很多常見的套件（例如：Linq、Cysharp系列）也都會使用這種寫法，通常是在以介面行為的基礎上去做擴充，這也可以避免類別的行為過多的情況。
3. 兩件事情來看，(1)確實能利用你說的方法，只是因為設定上多了無屬性，所以結構上無法這樣實現。(2)需求面來講，你永遠無法預測這些修改，所以能做的事情有：
   i. 如果能熟用這個寫法，直接寫了沒關係（結構允許的話）
   ii. 先走最簡單的路線處理，重構時尋找瓶頸處理，以這個的例子來說，通常不是瓶頸
   iii. 利用設計模式中的策略模式，將這些判斷封裝成一個物件處理，但如果需求根本沒變，那也是一種過度設計
   上述的處理並不是全部的解，還有很多種做法
   不過總的來說，這確實是需要經驗以及需求方的配合，如果需求方未經計畫（立即、且不考慮其他模組的影響）修改的話，那麼你做再多的設計與判斷都會整個打掉重來

[zxc30314]

pruss（程式）

我的答案

  public class Question2
    {
        bool CheckOutOfValue(int value, double minValue, double maxValue) => minValue <= value && value <= maxValue;

        public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
        {
            var maxValue = Math.Pow(10, 7);
            var maxLength = 1000;
            if (!CheckOutOfValue(status, 0, maxValue))
            {
                throw new ArgumentException($"{nameof(status)} value out of bounds");
            }

            if (monsters.Any(monster => !CheckOutOfValue(monster, 0, maxValue)))
            {
                throw new ArgumentException($"{nameof(monsters)} value out of bounds");
            }

            if (!monsters.Any() || monsters.Length > maxLength)
            {
                throw new ArgumentException($"{nameof(monsters)} length out of bounds");
            }

            if (!monsterElementals.Any() || monsterElementals.Length > maxLength)
            {
                throw new ArgumentException($"{nameof(monsterElementals)} length out of bounds");
            }

            if (elementals.Length != monsters.Length || elementals.Length != monsterElementals.Length)
            {
                throw new ArgumentException($"{nameof(elementals)} length and {nameof(elementals)} length and {nameof(monsterElementals)} length not equal");
            }

            var data = elementals.Select((selfElemental, i) => new {selfElemental, monster = monsters[i], monsterElemental = monsterElementals[i]});

            foreach (var step in data)
            {
                var selfValue = status * DamageDouble(step.selfElemental, step.monsterElemental);
                var monsterValue = step.monster * DamageDouble(step.monsterElemental, step.selfElemental);
                if (selfValue < monsterValue)
                {
                    return false;
                }

                status += step.monster;
            }

            return true;
        }

        double DamageDouble(EElemental attacker, EElemental defender)
        {
            return (attacker, defender) switch
            {
                (EElemental.Water, EElemental.Fire) => 2,
                (EElemental.Fire, EElemental.Wind) => 2,
                (EElemental.Wind, EElemental.Water) => 2,
                _ => 1
            };
        }
    }

單元測試結果

[jack81722]

select的內部也會跑一次迴圈
等於你這個方法重複做了一次迴圈
略為複雜了一點

[qs4635463]

JSheng（程式）

我的答案

public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
{
    for(int i = 0; i < elementals.Length; ++i)
    {
        int newPlayerStatus = status *= (IsPrevail(elementals[i], monsterElementals[i]) ? 2 : 1);
        int newMonsterDamage = monsters[i] *= (IsPrevail(monsterElementals[i], elementals[i]) ? 2 : 1);

        if(newPlayerStatus < newMonsterDamage)
        {
            return false;
        }
        else
        {
            status += monsters[i];
        }
    }

    return true;
}

private bool IsPrevail(EElemental _from, EElemental _to)
{
    return _from == EElemental.Fire && _to == EElemental.Wind || _from == EElemental.Water && _to == EElemental.Fire || _from == EElemental.Wind && _to == EElemental.Water;
}

[TWEdward]

TWEdward(新人/程式/企劃)

我的答案

public class Question2
    {
        public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
        {
            //return false;

            for (int i = 0; i < monsters.Length; i++)
            {
                if (status * twoORone(elementals[i], (monsterElementals[i])) >= monsters[i] * twoORone(monsterElementals[i], (elementals[i])))
                    status = status + monsters[i];
                else
                    return false;
            }
            return true;



            int twoORone(EElemental statusElementalPower,EElemental monsterElenmentalPower) 
            {
                if (statusElementalPower == EElemental.Fire && monsterElenmentalPower == EElemental.Wind ||
                    statusElementalPower == EElemental.Water && monsterElenmentalPower == EElemental.Fire ||
                    statusElementalPower == EElemental.Wind && monsterElenmentalPower == EElemental.Water)
                    return 2;
                else
                    return 1;
            }
            
        }
    }

我的心得感想

這題真的難，很考驗程式碼思路邏輯，隔了快兩個禮拜，我還是沒寫出正確的程式碼邏輯，程式碼邏輯怎麼寫都不對，就是過不了單元測試，後來覺得拖太久了，有偷看答案一下，對邏輯有了印象後，才終於寫出來通過單元測試，我好慚愧啊!!啊!!啊!! 還有我也要謝謝老師出的這道題目有讓我印象深刻，真的重寫超多次測試超多次，也希望老師可以的話，類似這種很考驗思路邏輯的題目，能再多出個幾題嗎??因為我買來自學的書，題目沒那麼考驗思路邏輯，也沒有單元測試可以玩，因此像這種很考驗思路邏輯也有加上單元測試的腦力激盪題目，請再給我多來個幾題吧!!

[jack81722]

出題其實更難ＸＤ
要考慮到學生的程度不同、錯誤的可能性、課程講到的東西、一個溫馨感人的故事（？）等等
確實這樣的練習我也會覺得已經算少了
雖然還沒有開演算法的課，不過也可以先介紹leetcode和codewar給你
以初學者來說，先寫基礎(easy)的題目即可

至於看答案這件事情有時無可避免的，也不用這麼氣餒
學會找資料、參考他人的作法也是重要的解決手段

[cliffleecl]

Cliff Lee CL (程式、專案管理)

我的答案

public class Question2
{
    static readonly float[,] ElementalMatrix = {
        {1, 1, 1, 1},
        {1, 1, 1, 2},
        {1, 2, 1, 1},
        {1, 1, 2, 1}
    };

    public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
    {
        for (var i = 0; i < monsters.Length; i++)
        {
            var playerElemental = (int)elementals[i];
            var monsterElemental = (int)monsterElementals[i];
            var playerMultiplier = ElementalMatrix[playerElemental, monsterElemental];
            var monsterMultiplier = ElementalMatrix[monsterElemental, playerElemental];
            
            if (status * playerMultiplier < monsters[i] * monsterMultiplier)
                return false;
            status += monsters[i];
        }
        return true;
    }
}

最初是想說用 Dictionary 來做相剋的查找表，但想說還沒教到
試著在目前教到的東西內想其他想法，就想到或許二維陣列也可以用

[jack81722]

這樣也不錯，空間換時間
倒也沒有限制作法，其他學生成長後回過頭（如果會的話）來看看不同的解法，也是會有新的思路

[dun047]

歐雷(程式)

答案

        public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
        {
            EElemental curElemental;
            int CurentStatus;
            int MonsterStatus;
            for (int i = 0; i < elementals.Length; i++)
            {
                CurentStatus = status;
                MonsterStatus = monsters[i];
                curElemental = elementals[i] | monsterElementals[i];//判斷屬性組合
                switch ((int)curElemental)
                {
                    case 3:
                        if (elementals[i] == EElemental.Water) CurentStatus *= 2;
                        else MonsterStatus *= 2;
                        break;
                    case 6:
                        if (elementals[i] == EElemental.Wind) CurentStatus *= 2;
                        else MonsterStatus *= 2;
                        break;
                    case 5:
                        if (elementals[i] == EElemental.Fire) CurentStatus *= 2;
                        else MonsterStatus *= 2;
                        break;
                    default:
                        CurentStatus = status;
                        MonsterStatus = monsters[i];
                        break;
                }
                if (CurentStatus >= MonsterStatus) status += monsters[i];
                else return false;
            }
            return true;
        }

嘗試使用位元來寫題目,思考了許久,若有更好的位元寫法請再告訴我,謝謝!

[MurasakiAurora]

極光（程式）

我的答案

  public class Question2
    {
        public bool CanWin(int status, EElemental[] elementals, int[] monsters, EElemental[] monsterElementals)
        {
            for (int i = 0; i <= monsters.Length - 1; i++)
            {
                if (status * Bonus(elementals[i],monsterElementals[i])<monsters[i] * Bonus(monsterElementals[i],elementals[i]))
                {
                    return false;
                    
                }
                else
                {
                    status = status + monsters[i];
                }
                
            }
            return true;
        }

        int Bonus(EElemental atkker, EElemental defender)
        {
            if (atkker == EElemental.Fire && defender == EElemental.Wind ||
                atkker == EElemental.Water && defender == EElemental.Fire ||
                atkker == EElemental.Wind && defender == EElemental.Water)
            {
                return 2;
            }
            else
            {
                return 1;
            }
        }
    }