示例#1
0
    public int[] solution(string S, int[] P, int[] Q)
    {
        // write your code in C# 6.0 with .NET 4.5 (Mono)
        Dictionary <char, int> impactMap = new Dictionary <char, int> {
            { 'A', 1 },
            { 'C', 2 },
            { 'G', 3 },
            { 'T', 4 },
        };

        LinkedValue []      impact = new LinkedValue[S.Length];
        Stack <LinkedValue> stack  = new Stack <LinkedValue>();

        for (var i = 0; i < S.Length; i++)
        {
            impact[i] = new LinkedValue
            {
                value       = impactMap[S[i]],
                nextMinimum = null
            };
            while (stack.Count > 0 && impact[i].value < stack.Peek().value)
            {
                stack.Pop().nextMinimum = i;
            }
            if (impact[i].value > 1)
            {
                stack.Push(impact[i]);
            }
        }
        int [] r = new int[P.Length];
        for (var i = 0; i < P.Length; i++)
        {
            LinkedValue current = impact[P[i]];
            if (current.value > 1)
            {
                while ((current.nextMinimum ?? Q[i] + 1) <= Q[i])
                {
                    current = impact[current.nextMinimum.Value];
                }
            }
            r[i] = current.value;
        }
        return(r);
    }
示例#2
0
    public int[] solution(string S, int[] P, int[] Q)
    {
        var impactMap = new Dictionary <char, int> {
            { 'A', 1 },
            { 'C', 2 },
            { 'G', 3 },
            { 'T', 4 },
        };
        var impact = new LinkedValue[S.Length];
        var stack  = new Stack <LinkedValue>();

        for (var i = -1; ++i < S.Length;)
        {
            impact[i] = new LinkedValue {
                value       = impactMap[S[i]],
                nextMinimum = null
            };
            while (stack.Count > 0 && impact[i].value < stack.Peek().value)
            {
                stack.Pop().nextMinimum = i;
            }
            if (impact[i].value > 1)
            {
                stack.Push(impact[i]);
            }
        }
        var r = new int[P.Length];

        for (var i = -1; ++i < P.Length;)
        {
            var current = impact[P[i]];
            if (current.value > 1)
            {
                while ((current.nextMinimum ?? Q[i] + 1) <= Q[i])
                {
                    current = impact[current.nextMinimum.Value];
                }
            }
            r[i] = current.value;
        }
        return(r);
    }
示例#3
0
        public static int[] Execute(string s, int[] p, int[] q)
        {
            //Dictionary<string, int> dnaSequenceDictionary = new Dictionary<string, int>
            //{
            //    {"A", 1},
            //    {"C", 2},
            //    {"G", 3},
            //    {"T", 4}
            //};

            //var stringAsCharArray = S.ToCharArray();
            //int[] result = new int[P.Length];

            //for (int i = 0; i < P.Length; i++)
            //{

            //    var key1 = stringAsCharArray[P[i]];
            //    var key2 = stringAsCharArray[Q[i]];

            //    var difference = dnaSequenceDictionary[$"{key1}"] > dnaSequenceDictionary[$"{key2}"] ? dnaSequenceDictionary[$"{key2}"] : dnaSequenceDictionary[$"{key1}"];
            //    result[i] = difference;
            //}

            //return result;

            var impactMap = new Dictionary <char, int> {
                { 'A', 1 },
                { 'C', 2 },
                { 'G', 3 },
                { 'T', 4 },
            };
            var impact = new LinkedValue[s.Length];
            var stack  = new Stack <LinkedValue>();

            for (var i = -1; ++i < s.Length;)
            {
                impact[i] = new LinkedValue
                {
                    Value       = impactMap[s[i]],
                    NextMinimum = null
                };
                while (stack.Count > 0 && impact[i].Value < stack.Peek().Value)
                {
                    stack.Pop().NextMinimum = i;
                }
                if (impact[i].Value > 1)
                {
                    stack.Push(impact[i]);
                }
            }
            var r = new int[p.Length];

            for (var i = -1; ++i < p.Length;)
            {
                var current = impact[p[i]];
                if (current.Value > 1)
                {
                    while ((current.NextMinimum ?? q[i] + 1) <= q[i])
                    {
                        current = impact[current.NextMinimum.Value];
                    }
                }
                r[i] = current.Value;
            }
            return(r);
        }