函数与逻辑

|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
 
class WordFrequency
{
    static Dictionary<string, int> CountWords(string text)
    {
        if (string.IsNullOrWhiteSpace(text))
            return new Dictionary<string, int>();
 
        // 使用正则表达式提取单词（字母序列）
        var words = Regex.Matches(text, @"\b[a-zA-Z]+\b")
            .Cast<Match>()
            .Select(m => m.Value.ToLowerInvariant());
 
        var dict = new Dictionary<string, int>();
        foreach (var word in words)
        {
            if (dict.ContainsKey(word))
                dict[word]++;
            else
                dict[word] = 1;
        }
 
        return dict;
    }
 
    static void Main()
    {
        string text = "The quick brown fox jumps over the lazy dog. The dog was not lazy.";
        var wordCounts = CountWords(text);
 
        var top10 = wordCounts
            .OrderByDescending(kvp => kvp.Value)
            .Take(10);
 
        Console.WriteLine("前10个高频词：");
        foreach (var kvp in top10)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value}");
        }
    }
}

|
前10个高频词：
the: 2
dog: 2
quick: 1
brown: 1
fox: 1
jumps: 1
over: 1
lazy: 2
was: 1
not: 1

|
using System;
using System.Collections.Generic;
using System.Linq;
 
class ScheduleMerger
{
    // 合并重叠的时间段
    static List<(TimeSpan start, TimeSpan end)> MergeIntervals(
        List<(TimeSpan start, TimeSpan end)> intervals)
    {
        if (intervals == null || intervals.Count == 0)
            return new List<(TimeSpan, TimeSpan)>();
 
        // 按开始时间排序
        var sorted = intervals.OrderBy(i => i.start).ToList();
        var merged = new List<(TimeSpan, TimeSpan)> { sorted[0] };
 
        for (int i = 1; i < sorted.Count; i++)
        {
            var current = sorted[i];
            var last = merged[merged.Count - 1];
 
            // 如果当前区间与最后一个合并区间重叠，则合并
            if (current.start <= last.end)
            {
                merged[merged.Count - 1] = (
                    last.start,
                    current.end > last.end ? current.end : last.end
                );
            }
            else
            {
                merged.Add(current);
            }
        }
 
        return merged;
    }
 
    // 找出空闲时段
    static List<(TimeSpan start, TimeSpan end)> FindFreeSlots(
        List<(TimeSpan start, TimeSpan end)> busySlots,
        TimeSpan workStart,
        TimeSpan workEnd)
    {
        var freeSlots = new List<(TimeSpan, TimeSpan)>();
        var merged = MergeIntervals(busySlots);
 
        TimeSpan current = workStart;
 
        foreach (var busy in merged)
        {
            if (current < busy.start)
            {
                freeSlots.Add((current, busy.start));
            }
            current = busy.end > current ? busy.end : current;
        }
 
        if (current < workEnd)
        {
            freeSlots.Add((current, workEnd));
        }
 
        return freeSlots;
    }
 
    static void Main()
    {
        // 示例：两个人的忙碌时段
        var person1 = new List<(TimeSpan, TimeSpan)>
        {
            (TimeSpan.Parse("09:00"), TimeSpan.Parse("10:30")),
            (TimeSpan.Parse("14:00"), TimeSpan.Parse("15:30"))
        };
 
        var person2 = new List<(TimeSpan, TimeSpan)>
        {
            (TimeSpan.Parse("10:00"), TimeSpan.Parse("11:00")),
            (TimeSpan.Parse("13:00"), TimeSpan.Parse("14:30"))
        };
 
        // 合并两个人的忙碌时段
        var allBusy = new List<(TimeSpan, TimeSpan)>();
        allBusy.AddRange(person1);
        allBusy.AddRange(person2);
 
        var merged = MergeIntervals(allBusy);
        Console.WriteLine("合并后的忙碌时段：");
        foreach (var slot in merged)
        {
            Console.WriteLine($"{slot.start:hh\\:mm} - {slot.end:hh\\:mm}");
        }
 
        // 找出空闲时段（工作时间 09:00-18:00）
        var freeSlots = FindFreeSlots(
            allBusy,
            TimeSpan.Parse("09:00"),
            TimeSpan.Parse("18:00")
        );
 
        Console.WriteLine("\n空闲时段：");
        foreach (var slot in freeSlots)
        {
            Console.WriteLine($"{slot.start:hh\\:mm} - {slot.end:hh\\:mm}");
        }
    }
}

|
合并后的忙碌时段：
09:00 - 11:00
13:00 - 15:30
 
空闲时段：
11:00 - 13:00
15:30 - 18:00

|
using System;
using System.Collections.Generic;
using System.Linq;
 
class ExpressionCalculator
{
    // 获取运算符优先级
    static int GetPrecedence(char op)
    {
        return op switch
        {
            '+' or '-' => 1,
            '*' or '/' => 2,
            _ => 0
        };
    }
 
    // 中缀转后缀
    static string InfixToPostfix(string infix)
    {
        var output = new System.Text.StringBuilder();
        var stack = new Stack<char>();
 
        foreach (char c in infix)
        {
            if (char.IsDigit(c))
            {
                output.Append(c);
            }
            else if (c == '(')
            {
                stack.Push(c);
            }
            else if (c == ')')
            {
                while (stack.Count > 0 && stack.Peek() != '(')
                {
                    output.Append(stack.Pop());
                }
                stack.Pop(); // 弹出 '('
            }
            else if (c == '+' || c == '-' || c == '*' || c == '/')
            {
                while (stack.Count > 0 &&
                       stack.Peek() != '(' &&
                       GetPrecedence(stack.Peek()) >= GetPrecedence(c))
                {
                    output.Append(stack.Pop());
                }
                stack.Push(c);
            }
        }
 
        while (stack.Count > 0)
        {
            output.Append(stack.Pop());
        }
 
        return output.ToString();
    }
 
    // 计算后缀表达式
    static double EvaluatePostfix(string postfix)
    {
        var stack = new Stack<double>();
 
        foreach (char c in postfix)
        {
            if (char.IsDigit(c))
            {
                stack.Push(double.Parse(c.ToString()));
            }
            else
            {
                double b = stack.Pop();
                double a = stack.Pop();
                double result = c switch
                {
                    '+' => a + b,
                    '-' => a - b,
                    '*' => a * b,
                    '/' => a / b,
                    _ => throw new ArgumentException($"未知运算符: {c}")
                };
                stack.Push(result);
            }
        }
 
        return stack.Pop();
    }
 
    static void Main()
    {
        string infix = "(3+4)*5-6";
        Console.WriteLine($"中缀表达式: {infix}");
 
        string postfix = InfixToPostfix(infix);
        Console.WriteLine($"后缀表达式: {postfix}");
 
        double result = EvaluatePostfix(postfix);
        Console.WriteLine($"计算结果: {result}");
    }
}

|
中缀表达式: (3+4)*5-6
后缀表达式: 34+5*6-
计算结果: 29