【总结】.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 = 1;
            int count = 0;
            //第一步：把一维数组的值和次数存入Dictionary中
            for (int i = 0; i < length; i++)
            {
                if (!map.ContainsKey(input[i]))
                {
                    times = 1;
                    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 = 0; i < count; i++)
            {
                result[i] = list[i];
            }
            return result;
        }
    }

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

 

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

int minTimes = 2;

var array = new int[] { 1, 1, 1, 2, 5, 5 };

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[] { 1, 1, 1, 2, 5, 5 };
           var q = FindDuplication(array, 2);
       }

       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 = 0; i < inputs.Length; i++)
          {
              if (!dict.ContainsKey(inputs[i]))
                  dict.Add(inputs[i], 1);
              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[2]{'，','。'});
            int i = 0;
            foreach (string item in poemSingle)
            {
                i++;
                if (!string.IsNullOrEmpty(item))
                {
                    builder.Append(InversePoem(item));
                    if (i % 2==0)
                    {
                        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 = 0; i < length/2; i++)
            {
                temp=ch[i];
                ch[i] = ch[length - i-1];
                ch[length - i-1] = temp;
            }
            return new String(ch);
        }
    }

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

 

@chinaonl

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

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

@ 菜刀和板砖

var str = "，白日依山尽，黄河入海流。欲穷千里目，，更上一层楼。";
var signs = str.Where(c => c == '，' || c == '。').ToArray();
var array = str.Trim().Split(new char[2] { '，', '。' });
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), 2) + Math.Pow((point.Y - this.Center.Y), 2));
            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三个判断都是比较容易实现的。

 三、总结

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