【总结】.Net面试题集锦 (二)

一、前面的话

本文的面试题不是很难，这里只是想记录个人的思考过程，另一方面希望有更好的解决办法的大牛留下宝贵的思路，大家共同学习进步。

二、题目

思路：第一步：把一维数组的值和次数存入Dictionary中；

第二步：获取Dictionary中大于等于指定值的元素存入List；

第三步：将结果存入int数组并返回结果

　　

     //声明数组中重复次数大于等于指定次数的接口
     public interface IDuplicationFinder
     {
         int[] FindDuplication(int[] input, uint minTimes);
     }

     //检测数组类
     public class DuplicationFinder : IDuplicationFinder
     {
         int[] result=null;
         Dictionary<int, int> map = new Dictionary<int, int>();
         List<int> list = new List<int>();
         public int[] FindDuplication(int[] input, uint minTimes)
         {
             int length = input.Length;
             int times = ;
             int count = ;
             //第一步：把一维数组的值和次数存入Dictionary中
             for (int i = ; i < length; i++)
             {
                 if (!map.ContainsKey(input[i]))
                 {
                     times = ;
                     map.Add(input[i], times);
                 }
                 else
                 {
                     times = map[input[i]];
                     times++;
                     map.Remove(input[i]);
                     map.Add(input[i], times);
                 }
             }
             //第二步：获取Dictionary中大于等于指定值的元素存入List
             foreach (KeyValuePair<int,int> item in map)
             {
                 if (item.Value >= minTimes)
                 {
                     list.Add(item.Key);
                 }
             }
             count = list.Count;
             result = new int[count];
             //第三步：将结果存入int数组并返回结果
             for (int i = ; i < count; i++)
             {
                 result[i] = list[i];
             }
             return result;
         }
     }

注：以下是各位园友对上面题目的补充，我把这些内容加进来~

@浩GE 顺便在写下第一题使用Linq的解法，特殊情况0就不写出来了。

 int minTimes = ;

 var array = new int[] { , , , , ,  };

 var distinctArray = array.Distinct();

 var results = distinctArray

     .ToDictionary(num => num, num => array.Count(i => i == num))

     .Where(p => p.Value >= minTimes)

     .Select(p => p.Key)

     .ToArray();

        public static void Main()
        {
            var array = new int[] { , , , , ,  };
            var q = FindDuplication(array, );
        }

        public static int[] FindDuplication(int[] input, uint minTimes)
        {

            return (from c in input

                    group c by c into g

                    let count = g.Count()

                    where count >= minTimes

                    select g.Key).ToArray();
        }

@???  第一题代码可以优化

           Dictionary<int, int> dict = new Dictionary<int, int>();
           for (int i = ; i < inputs.Length; i++)
           {
               if (!dict.ContainsKey(inputs[i]))
                   dict.Add(inputs[i], );
               else
                   dict[inputs[i]]++;
           }
           List<int> list = new List<int>();
           IEnumerable<KeyValuePair<int, int>> tmp = dict.Where(w => w.Value >= minTimes);
           foreach (KeyValuePair<int, int> item in tmp)
               list.Add(item.Key);
           return list.ToArray();

@菜刀和板砖

 var result=array
 .GroupBy(c=>c).Select(c=>new {c.Key,Num=c.Count()})
 .Where(c=>c.Num>=minTimes)
 .Select(c=>c.Key)
 .ToArray()

@ lambert_li

 public int[] FindDuplication(int[] input, uint minTimes)
 {
      return input.GroupBy(m => m).Where(g=>g.Count() >= minTimes).Select(g=>g.Key).ToArray();
 }

思路：第一步：先把单句反转；

第二步：把反转后的四句组合；

     //声明字符反转接口
     public interface IstringInverter
     {
         string PiecewiseInvert(string input);
     }

     //字符串反转类
     public class stringInverter:IstringInverter
     {
         //第二步：把反转后的四句组合
         public string PiecewiseInvert(string input)
         {
             StringBuilder builder = new StringBuilder();
             string[] poemSingle=input.Trim().Split(new char[]{'，','。'});
             int i = ;
             foreach (string item in poemSingle)
             {
                 i++;
                 if (!string.IsNullOrEmpty(item))
                 {
                     builder.Append(InversePoem(item));
                     if (i % ==)
                     {
                         builder.Append('。');
                     }
                     else
                     {
                         builder.Append('，');
                     }
                 }
             }
             return builder.ToString();
         }
         //第一步：先把单句反转
         public string InversePoem(string singlePoem)
         {
             char[] ch = singlePoem.ToCharArray();
             int length = ch.Length;
             char temp;
             for (int i = ; i < length/; i++)
             {
                 temp=ch[i];
                 ch[i] = ch[length - i-];
                 ch[length - i-] = temp;
             }
             return new String(ch);
         }
     }

注：以下是各位园友对上面题目的补充，我把这些内容加进来~

@chinaonl

 const char FLAG1 = '，';
 const char FLAG2 = '。';

 static string PicewiseInvert(string input)
 {
     var result = new StringBuilder();
     for (int i = , index = ; i < input.Length; i++){
         if (input[i].Equals(FLAG1) || input[i].Equals(FLAG2){
             for (var prev = i - ; prev > index - ; prev--){
                 result.Append(input[prev]);
             }
             index = i + ;
             result.Append(input[i]);
         }
     }
     return result.ToString();
 }

@ 菜刀和板砖

 var str = "，白日依山尽，黄河入海流。欲穷千里目，，更上一层楼。";
 var signs = str.Where(c => c == '，' || c == '。').ToArray();
 var array = str.Trim().Split(new char[] { '，', '。' });
 var result = string.Join("",
     array.Select((c, i) => string.Join("", c.Reverse()) + (i == signs.Length ? "" : signs[i].ToString())));

思路：这个问题类似于形状间的碰撞检测，我觉得大致上可以分两类进行讨论，一类是矩形的四个顶点至少有一个在园内，这个很好理解，另一类就是矩形完全包围圆形，看到知乎上有一个比较好的回答，在此给出链接，可供参考，怎样判断平面上一个矩形和一个圆形是否有重叠？但是我想以一个更直观更好理解的方式来解决这个问题，目前第二种情形还没有仔细考虑，如果哪位园友有比较好的idea可以评论，我会加进来。

     //声明坐标结构体
     public struct Point
     {
         public double X;
         public double Y;
     }

     //圆形类
     public class Circle
     {
         private Point center;
         private double radius;
         public Point Center
         {
           get { return center; }
           set { center = value; }
         }
         public double Radius
         {
             get { return radius; }
             set { radius = value; }
         }
         public Circle(Point center,double radius)
         {
             this.Center = center;
             this.Radius = radius;
         }
         //判断矩形的四个顶点是否在圆的范围内
         public bool IsRectangleRepeate(Rectangle rec)
         {
             bool result = false;
             List<Point> recPoints = rec.Corners;
             foreach (Point item in recPoints)
             {
                 if (IsContainPoint(item))
                 {
                     result = true;
                     break;
                 }
             }
             return result;
         }
         //判断某个点是否在圆的范围内
         private bool IsContainPoint(Point point)
         {
             bool result = false;
             double distance = Math.Sqrt(Math.Pow((point.X - this.Center.X), ) + Math.Pow((point.Y - this.Center.Y), ));
             result = distance < this.radius ? true : false;
             return result;
         }

         //声明：还有一种情形尚未考虑在内，就是当矩形完全包围圆的时候
     }

     //矩形类
     public class Rectangle
     {
         private Point startPos;
         private double width;
         private double height;
         private List<Point> corners;
         public Point StartPos
         {
             get { return startPos; }
             set { startPos = value; }
         }
         public double Width
         {
             get { return width; }
             set { width = value; }
         }
         public double Height
         {
             get { return height; }
             set { height = value; }
         }
         public List<Point> Corners
         {
             get { return corners; }
             set { corners = value; }
         }
         public Rectangle(Point startPos,double width,double height)
         {
             this.StartPos = startPos;
             this.Width = width;
             this.Height = height;
             GetCorners();
         }

         public List<Point> GetCorners()
         {
             Corners = new List<Point>();
             Point leftTop = new Point() { X=StartPos.X,Y=StartPos.Y};
             Point rightTop = new Point() { X = StartPos.X+Width, Y = StartPos.Y };
             Point leftBottom = new Point() { X = StartPos.X, Y = StartPos.Y+Height };
             Point rightBottom = new Point() { X = StartPos.X + Width, Y = StartPos.Y+Height };
             Corners.Add(leftTop);
             Corners.Add(leftBottom);
             Corners.Add(rightTop);
             Corners.Add(rightBottom);
             return Corners;
         }
     }

注：以下是各位园友对上面题目的补充，我把这些内容加进来~

@爱编程的大叔
1、将圆心设定为原点（0，0），矩形坐标进行相应变换。
2、判断矩形的中心坐标在哪个象限（1、2、3、4）上。
3、以1象限为例，矩形与圆形相交的只有三种可能
     a. 左下角位于圆内部， 坐标：Left, bottom在圆形内部
     b. 下边切部份圆， 坐标：0,R在矩形内部
     c. 左下角坐标位于第三象限（与a判断部份重叠）
4、a\b\c三个判断都是比较容易实现的。

三、总结

这些题目其实很简单，但是一千个读者有一千个哈姆雷特，多样化的解决问题的方式会大大拓宽我们的思路，所以，打开你们的脑洞吧~~

还没有买到回家的票，肿么破 %>_<%