Example #1
0
 private Enumerator(ReadOnlyArrayWrapper <T> wrapper)
 {
     _arr = wrapper._arr ??
            throw new ArgumentException(
                      @"The array has not been initialized.", nameof(wrapper));
     _idx = -1;
 }
        private static int AccessViaField(ReadOnlyArrayWrapper <int> arrayWrapper)
        {
            int sum = 0;

            for (int i = 0; i < arrayWrapper.Length; i++)
            {
                sum += arrayWrapper.Array[i];
            }

            return(sum);
        }
        private static int AccessViaLocalVariable(ReadOnlyArrayWrapper <int> arrayWrapper)
        {
            int sum    = 0;
            int length = arrayWrapper.Length;

            int[] array = arrayWrapper.Array;
            for (int i = 0; i < length; i++)
            {
                sum += array[i];
            }

            return(sum);
        }
Example #4
0
 /// <summary>
 /// Create enumerator
 /// </summary>
 /// <param name="owner">the owner</param>
 /// <returns>an enumerator</returns>
 internal static Enumerator GetEnumerator(ReadOnlyArrayWrapper <T> owner) => new Enumerator(owner);
Example #5
0
        static bool ValidateLog(string gameLog, ReadOnlyArrayWrapper <UInt256> array)
        {
            if (string.IsNullOrWhiteSpace(gameLog) || array.IsDefault)
            {
                return(false);
            }
            var arr = gameLog.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);

            const string upTo = "0xDEAD_BEEF_CAFE_BABE_DEAD_BEEF_CAFE_BABE_DEAD_BEEF_CAFE_BABE_DEAD_BEEF_CAFE_BABE";
            const string oVal =
                "0xC0DE_D00D_FEA2_B00B_C0DE_D00D_FEA2_B00B_C0DE_D00D_FEA2_B00B_C0DE_D00D_FEA2_B00B";
            const string xVal =
                "0xFACE_C0CA_F00D_BAD0_FACE_C0CA_F00D_BAD0_FACE_C0CA_F00D_BAD0_FACE_C0CA_F00D_BAD0";

            int expectedExes = -1;
            int expectedOes  = -1;
            var strings      = (from str in arr
                                where str.StartsWith("Logged at") && (str.Contains(upTo, StringComparison.OrdinalIgnoreCase) ||
                                                                      str.Contains(xVal, StringComparison.OrdinalIgnoreCase) ||
                                                                      str.Contains(oVal, StringComparison.OrdinalIgnoreCase))
                                select str.Split(' ', StringSplitOptions.RemoveEmptyEntries)).ToArray();
            bool foundDeadBeef = false, foundCounts = false;
            int  indexOfDeadBeef = -1;
            int  strIdx          = -1;

            foreach (var item in strings)
            {
                ++strIdx;
                switch (item.Length)
                {
                case 23:
                    if (string.Equals(item[6].Trim(), upTo, StringComparison.OrdinalIgnoreCase))
                    {
                        if (foundDeadBeef)
                        {
                            return(false);
                        }
                        indexOfDeadBeef = strIdx;
                        foundDeadBeef   = true;
                    }

                    break;

                case 25:
                    string xCt      = item[4];
                    string oCt      = item[9];
                    bool   parsedOk = int.TryParse(oCt, out expectedOes) && int.TryParse(xCt, out expectedExes);
                    if (!parsedOk)
                    {
                        return(false);
                    }
                    foundCounts = true;
                    break;
                }

                if (foundCounts && foundDeadBeef)
                {
                    break;
                }
            }

            if (indexOfDeadBeef < 0 || indexOfDeadBeef >= strings.Length || expectedExes == -1 || expectedOes == -1)
            {
                return(false);
            }


            string deadBeef = strings[indexOfDeadBeef].Last();
            bool   gotIdx   = int.TryParse(deadBeef, out int lastIdxToConsider);

            if (!gotIdx)
            {
                return(false);
            }
            var constants     = new DeadBeefCafeBabeGameConstants();
            var slice         = array.AsSpan().Slice(0, lastIdxToConsider + 1);
            int xCount        = 0;
            int oCount        = 0;
            int deadBeefCount = 0;

            foreach (ref readonly var value in slice)
            {
                if (value == constants.LookForNumber)
                {
                    ++deadBeefCount;
                }
                else if (value == constants.XNumber)
                {
                    ++xCount;
                }
                else if (value == constants.ONumber)
                {
                    ++oCount;
                }
                else
                {
                    return(false);
                }
            }

            int difference = Math.Abs(xCount - oCount);

            if (difference == 0 || difference % 13 != 0)
            {
                return(false);
            }

            return(deadBeefCount == 1 && xCount == expectedExes &&
                   oCount == expectedOes);
        }