using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace T5
{
    public class Naapurit
    {
        public static void Main(string[] args)
        {
        }

        /// <summary>
        /// Aliohjelma palauttaa kokonaislukuna 2D-totuusarvotaulukon annetun alkion
        /// "naapureiden" määrän, eli niiden true-alkioiden määrän jotka
        /// ovat enintään 1 rivin ja 1 sarakkeen päässä.
        /// Esim matriisin
        ///  [ 1 1 1 ]
        ///  [ 0 1 0 ]
        ///  [ 1 0 0 ]
        /// alkiolla (0,0) on 2 naapuria,
        ///          (1,1) on 4 naapuria,
        ///          (2,0) on 1 naapuri,
        ///          (2,2) on 1 naapuri.
        /// (Tässä: 1 == true, 0 == false)
        /// </summary>
        /// <param name="taulukko">Tutkittava taulukko.</param>
        /// <param name="r">Tutkittavan alkion rivi-indeksi.</param>
        /// <param name="s">Tutkittavan alkion sarakeindeksi.</param>
        /// <returns>Viereisten true-alkioiden määrä.</returns>
        /// @example
        /// <pre name="test">
        /// bool[,] t = {{true,true,true}, {false,true,false}, {true,false,false}};
        /// Naapurit.MontakoNaapuria(t, 0, 0) === 2;
        /// Naapurit.MontakoNaapuria(t, 1, 1) === 4;
        /// Naapurit.MontakoNaapuria(t, 2, 0) === 1;
        /// Naapurit.MontakoNaapuria(t, 2, 2) === 1;
        /// bool[,] t2 = {{true}};
        /// Naapurit.MontakoNaapuria(t2, 0, 0) === 0;
        /// </pre>
        /// @endexample
        public static int MontakoNaapuria(bool[,] taulukko, int r, int s)
        {
            int naapureita = 0;
            int riviMin = Math.Max(0, r - 1);
            int riviMax = Math.Min(taulukko.GetLength(0) - 1, r + 1);
            int sarakeMin = Math.Max(0, s - 1);
            int sarakeMax = Math.Min(taulukko.GetLength(1) - 1, s + 1);

            for (int iy = riviMin; iy <= riviMax; iy++)
            {
                for (int ix = sarakeMin; ix <= sarakeMax; ix++)
                {
                    if (taulukko[iy, ix]) naapureita++;
                }
            }
            if (taulukko[r, s]) naapureita--;

            return naapureita;
        }
        /// <summary>
        /// Aliohjelma palauttaa kokonaislukuna 2D-totuusarvotaulukon annetun alkion
        /// "naapureiden" määrän, eli niiden true-alkioiden määrän jotka
        /// ovat enintään 1 rivin ja 1 sarakkeen päässä.
        /// Esim matriisin
        ///  [ 1 1 1 ]
        ///  [ 0 1 0 ]
        ///  [ 1 0 0 ]
        /// alkiolla (0,0) on 2 naapuria,
        ///          (1,1) on 4 naapuria,
        ///          (2,0) on 1 naapuri,
        ///          (2,2) on 1 naapuri.
        /// (Tässä: 1 == true, 0 == false)
        /// </summary>
        /// <param name="taulukko">Tutkittava taulukko.</param>
        /// <param name="r">Tutkittavan alkion rivi-indeksi.</param>
        /// <param name="s">Tutkittavan alkion sarakeindeksi.</param>
        /// <returns>Viereisten true-alkioiden määrä.</returns>
        /// @example
        /// <pre name="test">
        /// bool[,] t = {{true,true,true}, {false,true,false}, {true,false,false}};
        /// Naapurit.MontakoNaapurii(t, 0, 0) === 2;
        /// Naapurit.MontakoNaapurii(t, 1, 1) === 4;
        /// Naapurit.MontakoNaapurii(t, 2, 0) === 1;
        /// Naapurit.MontakoNaapurii(t, 2, 2) === 1;
        /// bool[,] t2 = {{true}};
        /// Naapurit.MontakoNaapurii(t2, 0, 0) === 0;
        /// </pre>
        /// @endexample
        public static int MontakoNaapurii(bool[,] taulukko, int r, int s)
        {
            int naapureita = 0;
            for (int i = r - 1; i <= r + 1; i++)
            {
                if (i < 0 || i >= taulukko.GetLength(0)) continue;
                for (int j = s - 1; j <= s + 1; j++)
                {
                    if (j < 0 || j >= taulukko.GetLength(1) || (r == i & s == j)) continue;
                    if (taulukko[i, j]) naapureita++;
                }
            }

            return naapureita;
        }

        /// <summary>
        /// Aliohjelma palauttaa kokonaislukuna 2D-totuusarvotaulukon annetun alkion
        /// "naapureiden" määrän, eli niiden true-alkioiden määrän jotka
        /// ovat enintään 1 rivin ja 1 sarakkeen päässä.
        /// Esim matriisin
        ///  [ 1 1 1 ]
        ///  [ 0 1 0 ]
        ///  [ 1 0 0 ]
        /// alkiolla (0,0) on 2 naapuria,
        ///          (1,1) on 4 naapuria,
        ///          (2,0) on 1 naapuri,
        ///          (2,2) on 1 naapuri.
        /// (Tässä: 1 == true, 0 == false)
        /// </summary>
        /// <param name="taulukko">Tutkittava taulukko.</param>
        /// <param name="r">Tutkittavan alkion rivi-indeksi.</param>
        /// <param name="s">Tutkittavan alkion sarakeindeksi.</param>
        /// <returns>Viereisten true-alkioiden määrä.</returns>
        /// @example
        /// <pre name="test">
        /// bool[,] t = {{true,true,true}, {false,true,false}, {true,false,false}};
        /// Naapurit.MontakoNaapuriii(t, 0, 0) === 2;
        /// Naapurit.MontakoNaapuriii(t, 1, 1) === 4;
        /// Naapurit.MontakoNaapuriii(t, 2, 0) === 1;
        /// Naapurit.MontakoNaapuriii(t, 2, 2) === 1;
        /// bool[,] t2 = {{true}};
        /// Naapurit.MontakoNaapuriii(t2, 0, 0) === 0;
        /// </pre>
        /// @endexample
        public static int MontakoNaapuriii(bool[,] taulukko, int r, int s)
        {
            int naapureita = 0;

            // Mitkä rivit ovat olemassa
            bool vasen = s > 0;
            bool oikea = s < taulukko.GetLength(1) - 1;
            bool yla = r > 0;
            bool ala = r < taulukko.GetLength(0) - 1;
            bool[] ehdot = new bool[] {
                yla && vasen && taulukko[r - 1, s - 1],
                yla && taulukko[r - 1, s],
                yla && oikea && taulukko[r - 1, s + 1],
                vasen && taulukko[r, s - 1],
                oikea && taulukko[r, s + 1],
                ala && vasen && taulukko[r + 1, s - 1],
                ala && taulukko[r + 1, s],
                ala && oikea && taulukko[r + 1, s + 1]
            };

            foreach (bool ehto in ehdot)
            {
                if (ehto) naapureita++;
            }

            return naapureita;
        }

    }
}