【總結】.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三個判斷都是比較容易實現的。

 三、總結

這些題目其實很簡單，但是一千個讀者有一千個哈姆雷特，多樣化的解決問題的方式會大大拓寬我們的思路，所以，打開你們的腦洞吧~~

還沒有買到回家的票，腫么破 %>_<%