C#练习题答案: 字母战争 - 空袭 - 信大屠杀【难度：2级】--景越C#经典编程题库,1000道C#基础练习题等你来挑战

字母战争 - 空袭 - 信大屠杀【难度:2级】:

答案1:

 using System;
 using System.Text;
 using System.Text.RegularExpressions;
 using System.Linq;
 using System.Collections.Generic;
 public class Kata
 {
    public static string AlphabetWar(string fight)
    {
      Regex rgx = new Regex(@"\w{0,1}[*+]\w{0,1}");
      Dictionary<char,int> lefts = new Dictionary<char, int>(){{'w',4}, {'p',3}, {'b',2}, {'s',1}};
      Dictionary<char,int> rights = new Dictionary<char,int>(){{'m',4}, {'q',3}, {'d',2}, {'z',1}};
      int leftPower = 0;
      int rightPower = 0;
     string afterBombing = rgx.Replace(fight, "");
      foreach(char c in afterBombing)
      {
        if(lefts.ContainsKey(c)) leftPower += lefts[c];
        else if(rights.ContainsKey(c)) rightPower += rights[c];
      }
      if (leftPower == rightPower) return "Let's fight again!";
      else return (leftPower > rightPower)? "Left side wins!":"Right side wins!";
    }
 }​

答案2:

using System.Text.RegularExpressions;
using System.Collections.Generic;
using System.Linq;

public class Kata
 {
    public static string AlphabetWar(string fight)
    {
      string bombExploded = Regex.Replace(fight, @".?[*]+.?", @"___");
      Dictionary<char, int> powers = new Dictionary<char, int>()
      {
      {'w',-4},{'p',-3},{'b',-2},{'s',-1},
      {'m',4},{'q', 3},{'d',2},{'z',1}
      };
      int totalPower = bombExploded.Where(x => powers.ContainsKey(x)).Select(x => powers[x]).Sum();
      return (totalPower == 0) ? "Let's fight again!": (totalPower > 0) ? "Right side wins!" : "Left side wins!";
    }
 }​

答案3:

using System; 
using System.Collections.Generic;
using System.Linq;
 
 public class Kata
 {
    public static string AlphabetWar(string fight)
    {
      int left = 0;
      int right = 0;
      
      int w = 4;
      int p = 3;
      int b = 2;
      int s = 1;
      
      int m = 4;
      int q = 3;
      int d = 2;
      int z = 1;
      
      string[] leftLetters = {"w", "p", "b", "s"};
      string[] rightLetters = {"m", "q", "d", "z"};
      char[] fightLetters = fight.ToCharArray();
      List<char> aliveLetters = fightLetters.ToList();
      
      Console.WriteLine("***START***");
      Console.WriteLine(fight);
      Console.WriteLine(fightLetters.Length);
      for(int i = 0; i < fightLetters.Length; i++)
      {
        string letter = fightLetters[i].ToString();
        
        if(letter == "*")
        {
            Console.WriteLine(i);
            if(i == 0 &amp;&amp; fightLetters.Length > 1)
            {
              Console.WriteLine("i == 0 and length > 1");
              //aliveLetters.RemoveAt(i+1);
              aliveLetters[i+1] = Convert.ToChar("-");
            }
            else if(i == fightLetters.Length - 1)
            {
              Console.WriteLine("i == length - 1");
              //aliveLetters.RemoveAt(i-1);
              aliveLetters[i-1] = Convert.ToChar("-");
            }
            else
            {
              Console.WriteLine("Standard");
              aliveLetters[i+1] = Convert.ToChar("-");
              aliveLetters[i-1] = Convert.ToChar("-");
              //aliveLetters.RemoveAt(i+1);
              //aliveLetters.RemoveAt(i-1);
            }
            
            
            
        }

        //Console.WriteLine(aliveLetters[i]);
    
        
      }
      
      for(int ii = 0; ii < aliveLetters.Count; ii++)
      {
        Console.WriteLine("alive letters = " + aliveLetters[ii]);
        string letter = aliveLetters[ii].ToString();
        
        if(leftLetters.Contains(letter))
        {
          //Console.WriteLine("left " + aliveLetters[i]);
          
          switch(letter)
          {
            case "w":
              left+=4;
              break;
          
            case "p":
              left+=3;
              break;
              
            case "b":
              left+=2;
              break;
              
            case "s":
              left+=1;
              break;
          }
          
        }
        
        if(rightLetters.Contains(letter))
        {
          //Console.WriteLine("right " + aliveLetters[i]);

          switch(letter)
          {
            case "m":
              right+=4;
              break;
          
            case "q":
              right+=3;
              break;
              
            case "d":
              right+=2;
              break;
              
            case "z":
              right+=1;
              break;
          }
      
        }
      }
      
      Console.WriteLine("left = " + left);
      Console.WriteLine("right = " + right);
      Console.WriteLine("***END***");
      if(left > right)
      {
        return "Left side wins!";
      }
      else if(right > left)
      {
        return "Right side wins!";
      }
      else 
      {
        return "Let's fight again!";
      }
      
      //return "Have mercy!";
    }
 }​

答案4:

using System.Text.RegularExpressions;
using System.Linq;
public class Kata
{
  public static string AlphabetWar(string fight)
  {     
      var score = Regex.Replace(fight, @"(\w?\*\w?)|[^zdqmsbpw]", "").Select(c => "wpbs_zdqm".IndexOf(c) - 4).Sum();
      return score == 0 ? "Let's fight again!" : score < 0 ? "Left side wins!" : "Right side wins!";
  }
}​

答案5:

 using System.Text.RegularExpressions;
 
 public class Kata
 {
public static string AlphabetWar(string fight)
{
    const string left = "sbpw";
    const string right = "zdqm";

    int result = 0;

    fight = Regex.Replace(fight, @"\w?\*\w?", string.Empty);

    foreach (var c in fight)
    {
        if (left.Contains(c.ToString()))
        {
            result += (left.IndexOf(c.ToString()) + 1);
        }
        else if (right.Contains(c.ToString()))
        {
            result -= (right.IndexOf(c.ToString()) + 1);
        }
    }

    if (result == 0) return "Let's fight again!";

    var rr = result > 0 ? "Left" : "Right";
    return $"{rr} side wins!";
}

 }​

答案6:

using System.Linq; 
using System.Collections.Generic;

 public class Kata
 {
    private static Dictionary<char, int> leftDict = new Dictionary<char, int>(){
            { 'w', 4 },
            { 'p', 3 },
            { 'b', 2 },
            { 's', 1 }
            };

        private static Dictionary<char, int> rightDict = new Dictionary<char, int>(){
            { 'm', 4 },
            { 'q', 3 },
            { 'd', 2 },
            { 'z', 1 }
            };

        public static string AlphabetWar(string fight)
        {
            int left = 0;
            int right = 0;

            for (int i = 0; i < fight.Length; i++)
            {
                if (fight[i]!='*' &amp;&amp; (i == 0 || fight[i - 1] != '*') &amp;&amp; (i == fight.Length - 1 || fight[i + 1] != '*'))
                {
                    left+= leftDict.FirstOrDefault(kvp => kvp.Key == fight[i]).Value;
                    right += rightDict.FirstOrDefault(kvp => kvp.Key == fight[i]).Value;
                }
            }

            return left > right ? "Left side wins!" : left < right ? "Right side wins!" : "Let's fight again!";
        }
 }​

答案7:

using System.Collections.Generic;
using System.Text.RegularExpressions;

public class Kata
{
  private readonly static Dictionary<char, sbyte> letters = new Dictionary<char, sbyte>() {
    { 'w', 4 }, { 'p', 3 }, { 'b', 2 }, { 's', 1 }, { 'm', -4 }, { 'q', -3 }, { 'd', -2 }, { 'z', -1 }
  };

  private static Regex rex = new Regex(@"\*{2,}", RegexOptions.Compiled);
  private static Regex rex2 = new Regex(@"\*[a-z]", RegexOptions.Compiled);
  private static Regex rex3 = new Regex(@"[a-z]\*", RegexOptions.Compiled);

  public static string AlphabetWar(string fight)
  {
    fight = rex3.Replace(rex2.Replace(rex.Replace(fight, "*"), "*_"), "_*");

    int result = 0;

    foreach (char c in fight)
      result += letters.ContainsKey(c) ? letters[c] : 0;

    return result == 0 ? "Let's fight again!" : result > 0 ? "Left side wins!" : "Right side wins!";
  }
}​

答案8:

 public class Kata
 {
    public static string AlphabetWar(string fight)
    {
      var chars = fight.ToCharArray();
      for(int i=0; i < chars.Length; i++)
      {
        if(fight[i] != '*')
          continue;
        
        chars[i] =  '_';
        
        if(i-1 >= 0)
        {
          chars[i-1] = '_';
        }
        
        if(i+1 < chars.Length)
        {
          chars[i+1] = '_';
        }
      }
      
      var leftSum = 0;
      var rightSum = 0;
      foreach(var c in chars)
      {
        if(c == 'w')
          leftSum += 4;
        else if(c == 'p')
          leftSum += 3; 
        else if(c == 'b')
          leftSum += 2;  
        else if(c == 's')
          leftSum += 1;  
        
        if(c == 'm')
          rightSum += 4;  
        else if(c == 'q')
          rightSum += 3;   
        else if(c == 'd')
          rightSum += 2;  
        else if(c == 'z')
          rightSum += 1;   
      }
      
      if(leftSum == rightSum)
        return "Let's fight again!";
      
      if(leftSum > rightSum)
        return "Left side wins!";
      else
        return "Right side wins!";
    }
 }​

答案9:

using System;
using System.Collections.Generic;

 public class Kata
 {
    public static string AlphabetWar(string fight)
        {
            // creating a dictionary with the left side letters and their power
            IDictionary<string, int> leftPowerLetters = new Dictionary<string, int>
            {
                ["w"] = 4,
                ["p"] = 3,
                ["b"] = 2,
                ["s"] = 1
            };

            // creating a dictionary with the right side letters and their power
            IDictionary<string, int> rightPowerLetters = new Dictionary<string, int>
            {
                ["m"] = 4,
                ["q"] = 3,
                ["d"] = 2,
                ["z"] = 1,
            };

            char[] letterArray = fight.ToCharArray();
            int leftSidePower = 0;
            int rightSidePower = 0;

            // going through each character
            for (int i=0; i<letterArray.Length; i++)
            {
                for (int j=0; j<letterArray.Length; j++)
                {
                    // seeing if char is a bomb and killing the adjacent letters
                    if (letterArray[j] == '*' &amp;&amp; j == 0) letterArray[j + 1] = ' ';
                    else if (letterArray[j] == '*' &amp;&amp; j == letterArray.Length - 1) letterArray[j - 1] = ' ';
                    else if (letterArray[j] == '*' &amp;&amp; j != 0 &amp;&amp; j != letterArray.Length - 1)
                    {
                        if (letterArray[j - 1] != '*') letterArray[j - 1] = ' ';
                        if (letterArray[j + 1] != '*') letterArray[j + 1] = ' ';
                    }
                }

                // check if there is a left side power letter and add it to sum
                if (leftPowerLetters.ContainsKey(letterArray[i].ToString()))
                {
                    leftSidePower += leftPowerLetters[letterArray[i].ToString()];
                }
                // check if there is a right side power letter and add it to sum
                else if (rightPowerLetters.ContainsKey(letterArray[i].ToString()))
                {
                    rightSidePower += rightPowerLetters[letterArray[i].ToString()];
                }
            }

            // return which side wins
            if (leftSidePower > rightSidePower) return "Left side wins!";
            else if (rightSidePower > leftSidePower) return "Right side wins!";
            else return "Let's fight again!";
        }
 }​

答案10:

 using System;
 using System.Text.RegularExpressions;
 
 public class Kata
 {
    public static string AlphabetWar(string input)
    {
      char[] battlefield = input.ToCharArray();
            for (int i = 0; i < input.Length; i++)
            {
                if (battlefield[i] == '*')
                {
                    if (i != 0 &amp;&amp; battlefield[i-1] != '*')
                        battlefield[i - 1] = '_';
                    if (i != input.Length - 1 &amp;&amp; battlefield[i+1] != '*')
                        battlefield[i + 1] = '_';
                    battlefield[i] = '_';
                }
            }
            return Fight(string.Join("", battlefield));
    }
    
    public static string Fight(string input)
        {
            int leftSidePower = 0;
            int rightSidePower = 0;
            foreach (var letter in input)
            {
                switch (letter)
                {
                    case 'w':
                        leftSidePower += 4;
                        break;
                    case 'p':
                        leftSidePower += 3;
                        break;
                    case 'b':
                        leftSidePower += 2;
                        break;
                    case 's':
                        leftSidePower += 1;
                        break;
                    case 'm':
                        rightSidePower += 4;
                        break;
                    case 'q':
                        rightSidePower += 3;
                        break;
                    case 'd':
                        rightSidePower += 2;
                        break;
                    case 'z':
                        rightSidePower += 1;
                        break;
                }
            }

            if (leftSidePower > rightSidePower)
                return "Left side wins!";
            else if (rightSidePower > leftSidePower)
                return "Right side wins!";

            return "Let's fight again!";
        }
 }​