└── CodeSignal
    ├── Add.java
    ├── Circle_of_Numbers.java
    ├── shapeArea.java
    ├── Array_Replace.java
    ├── bishopAndPawn.java
    ├── checkPalindrome.java
    ├── depositProfit.java
    ├── Make_Array_Consecutive_2.java
    ├── centuryFromYear.java
    ├── evenDigitsOnly.java
    ├── arrayMaximalAdjacentDifference.java
    ├── alternatingSums.java
    ├── firstDigit.java
    ├── isBeautifulString.java
    ├── digitDegree.java
    ├── differentSymbolsNaive.java
    ├── areEquallyStrong.java
    ├── growingPlant.java
    ├── chessBoardCellColor.java
    ├── isLucky.java
    ├── adjacentElementsProduct.java
    ├── alphabeticShift.java
    ├── arrayMaxConsecutiveSum.java
    ├── palindromeRearranging.java
    ├── arrayChange.java
    ├── Add_Border.java
    ├── avoidObstacles.java
    ├── matrixElementsSum.java
    ├── VariableName.java
    ├── Sort_by_Height.java
    ├── BoxBlur.java
    ├── almostIncreasingSequence.java
    ├── Are_Similar.java
    ├── Knapsack_Light.java
    ├── absoluteValuesSumMinimization.java
    ├── All_Longest_Strings.java
    ├── commonCharacterCount.java
    ├── isIPv4Address.java
    ├── extractEachKth.java
    ├── stringsRearrangement.java
    └── Minesweeper.java


/CodeSignal/Add.java:
--------------------------------------------------------------------------------
1 | int add(int param1, int param2) {
2 |     return param1+param2;
3 | }


--------------------------------------------------------------------------------
/CodeSignal/Circle_of_Numbers.java:
--------------------------------------------------------------------------------
1 | int circleOfNumbers(int n, int firstNumber) {
2 |     return (n / 2 + firstNumber) % n;
3 | }


--------------------------------------------------------------------------------
/CodeSignal/shapeArea.java:
--------------------------------------------------------------------------------
1 | int shapeArea(int n) {
2 |     if(n == 1) return 1;
3 |     return 4*(n-1) + shapeArea(n-1);
4 | }


--------------------------------------------------------------------------------
/CodeSignal/Array_Replace.java:
--------------------------------------------------------------------------------
1 | int[] arrayReplace(int[] a, int x, int r) {
2 |     for(int i=0;i<a.length;i++){
3 |         if(a[i]==x)
4 |             a[i]=r;
5 |     }
6 |     return a;
7 | }


--------------------------------------------------------------------------------
/CodeSignal/bishopAndPawn.java:
--------------------------------------------------------------------------------
1 | boolean bishopAndPawn(String bishop, String pawn) {
2 |       return Math.abs(bishop.charAt(0) - pawn.charAt(0))== Math.abs(bishop.charAt(1) - pawn.charAt(1));
3 | }
4 | 


--------------------------------------------------------------------------------
/CodeSignal/checkPalindrome.java:
--------------------------------------------------------------------------------
1 | bool checkPalindrome(string s) {
2 |     int l=s.length();
3 |     for(int i=0;i<l;i++)
4 |         if(s[i]!=s[l-1-i])
5 |             return 0;
6 |     return 1;
7 | }
8 | 


--------------------------------------------------------------------------------
/CodeSignal/depositProfit.java:
--------------------------------------------------------------------------------
1 | int depositProfit(int deposit, int rate, int threshold) {
2 |     float d = deposit;
3 | 	for(int y = 1;; y++) 
4 |         if((d += rate / 100f * d) >= threshold)     
5 |             return y;
6 | }
7 | 


--------------------------------------------------------------------------------
/CodeSignal/Make_Array_Consecutive_2.java:
--------------------------------------------------------------------------------
1 | int makeArrayConsecutive2(int[] statues) {
2 |     Arrays.sort(statues);
3 |     int range= statues[statues.length-1]-statues[0]+1;
4 |     int ans =statues.length-range;
5 |     return Math.abs(ans);
6 | }


--------------------------------------------------------------------------------
/CodeSignal/centuryFromYear.java:
--------------------------------------------------------------------------------
 1 | int centuryFromYear(int year) {
 2 |     // return year/100+(year%100 != 0?1: 0);
 3 |     
 4 |     int n=year/100;
 5 |     if((year%100)!=0)
 6 |         return n+1;
 7 |     else
 8 |         return n;
 9 | }
10 | 


--------------------------------------------------------------------------------
/CodeSignal/evenDigitsOnly.java:
--------------------------------------------------------------------------------
1 | boolean evenDigitsOnly(int n) {
2 |     String s=Integer.toString(n);
3 |     for(int i=0;i<s.length();i++)
4 |         if(Character.getNumericValue(s.charAt(i))%2!=0)
5 |             return false;
6 |     return true;
7 | }
8 | 


--------------------------------------------------------------------------------
/CodeSignal/arrayMaximalAdjacentDifference.java:
--------------------------------------------------------------------------------
1 | int arrayMaximalAdjacentDifference(int[] inputArray) {
2 |     int a=Integer.MIN_VALUE;
3 |     for(int i=0;i<inputArray.length-1;i++)
4 |         a=Integer.max(a, Math.abs(inputArray[i]-inputArray[i+1]));
5 |     return a;
6 | }
7 | 


--------------------------------------------------------------------------------
/CodeSignal/alternatingSums.java:
--------------------------------------------------------------------------------
 1 | int[] alternatingSums(int[] a) {
 2 |     int s=0,t=0;
 3 | int b[]=new int[2];
 4 |  for(int i=0;i<a.length;i++){
 5 |      if(i%2!=0)
 6 |      s=s+a[i];
 7 |      else
 8 |      t=t+a[i];
 9 |  }
10 | b[0]=t;
11 | b[1]=s;
12 | return b;
13 | }
14 | 


--------------------------------------------------------------------------------
/CodeSignal/firstDigit.java:
--------------------------------------------------------------------------------
 1 | char firstDigit(String s) {
 2 |     char c='0';
 3 |     for(int i=0;i<s.length();i++){
 4 |         if(s.charAt(i)>='0' && s.charAt(i)<='9'){
 5 |             c=s.charAt(i);
 6 |             break;
 7 |         }
 8 |     }
 9 |     return c;
10 | }
11 | 


--------------------------------------------------------------------------------
/CodeSignal/isBeautifulString.java:
--------------------------------------------------------------------------------
1 | boolean isBeautifulString(String inputString) {
2 |     byte[] abc = new byte[26];
3 | 	    for(char c : inputString.toCharArray()) abc[c - 'a']++;
4 | 	    for(byte i = 0; i < 25; i++) if(abc[i + 1] > abc[i]) return false;
5 | 	    return true;
6 | }
7 | 


--------------------------------------------------------------------------------
/CodeSignal/digitDegree.java:
--------------------------------------------------------------------------------
 1 | int digitDegree(int n) {
 2 |     int c=0;
 3 |     while(n>=10){
 4 |         c++;
 5 |         int s=0;
 6 |         while(n>0){
 7 |             s+=(n%10);
 8 |             n/=10;
 9 |         }
10 |         n=s;
11 |     }
12 |     return c;
13 | }
14 | 


--------------------------------------------------------------------------------
/CodeSignal/differentSymbolsNaive.java:
--------------------------------------------------------------------------------
 1 | int differentSymbolsNaive(String s) {
 2 |     char c[]=s.toCharArray();
 3 |     int flag=1;
 4 |     Arrays.sort(c); 
 5 |     for(int i=0;i<c.length-1;i++)
 6 |         if(c[i]!=c[i+1])
 7 |             flag++;
 8 |             
 9 |    return flag;
10 | }


--------------------------------------------------------------------------------
/CodeSignal/areEquallyStrong.java:
--------------------------------------------------------------------------------
1 | boolean areEquallyStrong(int yourLeft, int yourRight, int friendsLeft, int friendsRight) {
2 |    boolean a=Integer.max(yourLeft, yourRight)==Integer.max(friendsRight,friendsLeft);
3 |    boolean b=Integer.min(yourLeft, yourRight)==Integer.min(friendsRight,friendsLeft);
4 |    return a&&b;
5 | }
6 | 


--------------------------------------------------------------------------------
/CodeSignal/growingPlant.java:
--------------------------------------------------------------------------------
 1 | int growingPlant(int upSpeed, int downSpeed, int desiredHeight) {
 2 |     int count = 0, height = 0;
 3 | 		while(true) {
 4 | 			height += upSpeed;
 5 | 			count++;
 6 | 			if(height >= desiredHeight) 
 7 |                 break;
 8 | 			height -= downSpeed;
 9 | 		}
10 | 	return count;
11 | }


--------------------------------------------------------------------------------
/CodeSignal/chessBoardCellColor.java:
--------------------------------------------------------------------------------
 1 | boolean chessBoardCellColor(String cell1, String cell2) {
 2 | 
 3 |         int x1 = cell1.charAt(0) - 'A'; 
 4 | 	    int y1= cell1.charAt(1)-'0';
 5 | 	    int x2 = cell2.charAt(0) - 'A';
 6 | 	    int y2= cell2.charAt(1)-'0';
 7 | 	    
 8 | 	    return (x1 + x2) % 2 == (y1 + y2) % 2;
 9 | }
10 | 


--------------------------------------------------------------------------------
/CodeSignal/isLucky.java:
--------------------------------------------------------------------------------
 1 | boolean isLucky(int n) {
 2 |     String s=Integer.toString(n);
 3 |     int x=s.length();
 4 |     int s1=0,s2=0;
 5 |     for(int i=0,j=x-1;i<j;i++,j--){
 6 |         s1+=Character.getNumericValue(s.charAt(i));
 7 |         s2+=Character.getNumericValue(s.charAt(j));
 8 |     }
 9 |     return s1==s2;
10 | }
11 | 


--------------------------------------------------------------------------------
/CodeSignal/adjacentElementsProduct.java:
--------------------------------------------------------------------------------
1 | int adjacentElementsProduct(arr_integer inputArray) {
2 |     int max = inputArray.arr[0] * inputArray.arr[1];
3 |     for(int i=1; i<inputArray.size-1; i++) {
4 |         int product = inputArray.arr[i] * inputArray.arr[i+1];
5 |         if (max < product) max = product;
6 |     }
7 |     return max;
8 | }


--------------------------------------------------------------------------------
/CodeSignal/alphabeticShift.java:
--------------------------------------------------------------------------------
 1 | String alphabeticShift(String s) {
 2 |     char[] g=s.toCharArray();
 3 |     for(int i=0;i<g.length;i++){
 4 |         if(g[i]=='z')
 5 |             g[i]='a';
 6 |         else
 7 |             g[i]++;
 8 |     }
 9 |     String a=new String(g);
10 |     return a;
11 | }
12 |                                  


--------------------------------------------------------------------------------
/CodeSignal/arrayMaxConsecutiveSum.java:
--------------------------------------------------------------------------------
 1 |  int arrayMaxConsecutiveSum(int[] a, int k) {
 2 |     int max = 0;  
 3 |     for(int i=0; i <= a.length - k; i++) {
 4 |         int sum=0;
 5 |         for(int j = i; j < i + k; j++) 
 6 |             sum += a[j];
 7 |         if(sum > max) 
 8 |             max = sum;
 9 |        }
10 |        return max;
11 | }
12 | 


--------------------------------------------------------------------------------
/CodeSignal/palindromeRearranging.java:
--------------------------------------------------------------------------------
 1 | boolean palindromeRearranging(String s) {
 2 |     char[] g = s.toCharArray();
 3 |     int[] o=new int[26];
 4 |     for(int i=0;i<g.length;i++)
 5 |         o[g[i]-'a']++;
 6 |     int x=0;
 7 |     for(int i=0;i<o.length;i++)
 8 |         if(o[i]%2!=0) 
 9 |             x++;
10 |     
11 |     return x<=1;
12 | }
13 | 


--------------------------------------------------------------------------------
/CodeSignal/arrayChange.java:
--------------------------------------------------------------------------------
 1 | int arrayChange(int[] inputArray) {
 2 |     int ans = 0;
 3 | 		
 4 | 		for(int i = 1; i < inputArray.length; i++) { 
 5 | 			if(inputArray[i-1] >= inputArray[i]) { 
 6 | 				int difference = Math.abs(inputArray[i - 1] - inputArray[i]) + 1 ;
 7 | 				inputArray[i] += difference;
 8 | 				ans += difference;
 9 | 			}
10 | 		}
11 | 		return ans;
12 | }
13 | 


--------------------------------------------------------------------------------
/CodeSignal/Add_Border.java:
--------------------------------------------------------------------------------
 1 | String[] addBorder(String[] picture) {
 2 |        String s="*";
 3 |        List<String>rg=new ArrayList<String>();
 4 |        rg.add(s.repeat(picture[0].length()+2));
 5 |         for(int i=0;i<picture.length;i++){
 6 |             rg.add(s+picture[i]+s);
 7 |         }
 8 |         rg.add(s.repeat(picture[0].length()+2));
 9 |         return rg.toArray(new String[0]);
10 | }


--------------------------------------------------------------------------------
/CodeSignal/avoidObstacles.java:
--------------------------------------------------------------------------------
 1 | int avoidObstacles(int[] a) {
 2 |     Arrays.sort(a);
 3 |     int c=0;   
 4 |     for(int i=1;;i++){ 
 5 |         c=0;           
 6 |         for(int j:a){  
 7 |             if(j%i==0)     
 8 |                 break;
 9 |             else
10 |                 c++;
11 |         }
12 |         if(c==a.length) 
13 |             return i;  
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/CodeSignal/matrixElementsSum.java:
--------------------------------------------------------------------------------
 1 | int matrixElementsSum(std::vector<std::vector<int>> matrix) {
 2 |     int c=0,i,j;
 3 |     for(i=0;i<matrix.size();i++){
 4 |         for(j=0;j<matrix[i].size();j++){
 5 |             if(i+1<matrix.size() && matrix[i][j]==0)
 6 |                 matrix[i+1][j]=0;
 7 |         if(matrix[i][j]!=0)
 8 |             c+=matrix[i][j];
 9 |         }
10 |     }
11 |     return c;
12 | }


--------------------------------------------------------------------------------
/CodeSignal/VariableName.java:
--------------------------------------------------------------------------------
 1 | boolean variableName(String name) {
 2 |     char []g=name.toCharArray();
 3 |     char c=g[0];
 4 |     if(c!='_' && !(c>=65 && c<=90) && !(c>=97 && c<=122))
 5 |         return false;
 6 |     for(int i=1;i<g.length;i++){
 7 |         c=g[i];
 8 |         if(!(c>=48 && c<=57) && c!='_' && !(c>=65 && c<=90) && !(c>=97 && c<=122))
 9 |             return false;
10 |     }    
11 |     return true;
12 | }


--------------------------------------------------------------------------------
/CodeSignal/Sort_by_Height.java:
--------------------------------------------------------------------------------
 1 | int[] sortByHeight(int[] a) {
 2 |     int []park=a.clone();
 3 |     Arrays.sort(a);
 4 |     List <Integer> rg=new ArrayList<Integer>();
 5 |     for(int i:a)
 6 |         if(i!=-1)
 7 |             rg.add(i);
 8 |     for(int i=0,j=0;i<park.length;i++){
 9 |         if(park[i]!=-1){
10 |             park[i]=rg.get(j);
11 |             j++;
12 |         }
13 |     }
14 |     return park;
15 | }
16 | 


--------------------------------------------------------------------------------
/CodeSignal/BoxBlur.java:
--------------------------------------------------------------------------------
 1 | int[][] boxBlur(int[][] image) {
 2 |     int r=image.length,g=image[0].length;
 3 |     int [][] a=new int [r-2][g-2];
 4 |     for(int i=1;i<r-1;i++)
 5 |         for(int j=1;j<g-1;j++)
 6 |             a[i-1][j-1]=getAvg(image,i,j);
 7 |    return a; 
 8 | }
 9 | int getAvg(int [][] a,int i,int j){
10 |     return (
11 |         a[i-1][j-1] + a[i-1][j] + a[i-1][j+1]+
12 |         a[i][j-1] + a[i][j] + a[i][j+1]+
13 |         a[i+1][j-1] + a[i+1][j] + a[i+1][j+1]
14 |     )/9;
15 | }


--------------------------------------------------------------------------------
/CodeSignal/almostIncreasingSequence.java:
--------------------------------------------------------------------------------
 1 | boolean almostIncreasingSequence(int[] a) {
 2 |     int s=a.length;
 3 |     int c=0;
 4 |     boolean x,y;
 5 |     if(s==2)
 6 |         return true;
 7 |     for(int i=0;i<s-1;i++){ 
 8 |         if(a[i+1]<=a[i]){      
 9 |             c++;
10 |             x=(i+2)<s && a[i+2]<=a[i];
11 |             y=(i-1)>=0 && a[i+1]<=a[i-1];
12 |             if(x&&y || c>=2)
13 |                 return false;
14 |         }
15 |     }
16 |     return true;
17 | }
18 | 


--------------------------------------------------------------------------------
/CodeSignal/Are_Similar.java:
--------------------------------------------------------------------------------
 1 |  boolean areSimilar(int[] a, int[] b) {
 2 |     Stack<Integer> rg = new Stack<Integer>();
 3 |     int c=0;
 4 |     for(int i=0;i<a.length;i++){
 5 |         if(a[i]!=b[i]){
 6 |             if(rg.isEmpty()){
 7 |                 rg.add(i);
 8 |                 c++;
 9 |             }   
10 |             else if(a[i]==b[rg.peek()]&&b[i]==a[rg.peek()])
11 |                 rg.pop();
12 |         }
13 |         if(c>=2)
14 |             return false;
15 |     }
16 |     return rg.empty();
17 | }
18 | 


--------------------------------------------------------------------------------
/CodeSignal/Knapsack_Light.java:
--------------------------------------------------------------------------------
 1 | int knapsackLight(int value1, int weight1, int value2, int weight2, int maxW) {
 2 |     	if(maxW >= weight1 + weight2) 
 3 |             return (value1 + value2);
 4 | 	    else if(value2 > value1 && maxW >= weight2) 
 5 |             return value2;
 6 | 	    else if(value1 > value2 && maxW >= weight1) 
 7 |             return value1;
 8 | 	    else if(maxW >= weight1) 
 9 |             return value1;
10 | 	    else if(maxW >= weight2) 
11 |             return value2;
12 |         return 0;
13 | 
14 | }
15 | 


--------------------------------------------------------------------------------
/CodeSignal/absoluteValuesSumMinimization.java:
--------------------------------------------------------------------------------
 1 | int absoluteValuesSumMinimization(int[] a) {
 2 |     int x=a[0],min=0,g=x;
 3 |     for(int j=0;j<a.length;j++){
 4 |         min+=Math.abs(a[j]-x);
 5 |     }
 6 |     for(int i=1;i<a.length;i++){
 7 |         x=a[i];
 8 |         int sum=0;
 9 |         for(int j=0;j<a.length;j++){
10 |             sum+=Math.abs(a[j]-x);
11 |         }
12 |         // System.out.println(sum);
13 |         if(min>sum){
14 |             min=sum;
15 |             g=x;
16 |             // System.out.println(g);
17 |         }
18 |     }
19 |     return g;
20 | }
21 | 


--------------------------------------------------------------------------------
/CodeSignal/All_Longest_Strings.java:
--------------------------------------------------------------------------------
 1 | String[] allLongestStrings(String[] s) {
 2 |     if(s.length==1)
 3 |         return s;
 4 |     int max=0,c=0,x=0;
 5 |     for(int i=0;i<s.length;i++){
 6 |         int size=s[i].length();
 7 |         if(max==size)
 8 |             c++;
 9 |         else if(max<size){
10 |             max=size;
11 |             c=1;
12 |         }
13 |     }
14 |     String [] g=new String[c];
15 |     for(int i=0;i<s.length;i++){
16 |         int size=s[i].length();
17 |         if(max==size){
18 |             g[x]=s[i];
19 |             x++;
20 |         }
21 |     }
22 |     return g;   
23 | }


--------------------------------------------------------------------------------
/CodeSignal/commonCharacterCount.java:
--------------------------------------------------------------------------------
 1 | int commonCharacterCount(String s1, String s2) {
 2 |     int c=0,k;
 3 |     ArrayList<Character>c1=new ArrayList<Character>();
 4 |     ArrayList<Character>c2=new ArrayList<Character>();
 5 |     for(int i=0;i<s1.length();i++){
 6 |         c1.add(s1.charAt(i));
 7 |     }
 8 |     for(int i=0;i<s2.length();i++){
 9 |         c2.add(s2.charAt(i));
10 |     }
11 |     for(char i:c1){
12 |         for(char j:c2){
13 |             if(i==j){
14 |                 c++;
15 |                 k=c2.indexOf(j);
16 |                 c2.remove(k);
17 |                 break;
18 |             }
19 |         }
20 |     }
21 |     return c;
22 | }
23 | 


--------------------------------------------------------------------------------
/CodeSignal/isIPv4Address.java:
--------------------------------------------------------------------------------
 1 | boolean isIPv4Address(String s) {
 2 |     
 3 |     int dot=0;
 4 |     
 5 |     for(int i=0;i<s.length();i++)
 6 |         if(s.charAt(i)=='.')
 7 |             dot++;   
 8 |             
 9 |     if(dot!=3)
10 |         return false;
11 |     
12 |     for(int i=0;i<s.length();i++){
13 |         String g="";
14 |         while(i<s.length() && s.charAt(i)!='.'){ 
15 |             boolean x=Character.isDigit(s.charAt(i));
16 |             if(!x)
17 |                 return false;
18 |             g+=s.charAt(i);
19 |             i++;
20 |         }
21 |         if(g.isEmpty() || g.length()>3 || Integer.valueOf(g)<0 || Integer.valueOf(g)>255 || (g.length()>1 && g.charAt(0)=='0'))
22 |             return false;
23 |     }
24 |     return true;
25 | }
26 | 


--------------------------------------------------------------------------------
/CodeSignal/extractEachKth.java:
--------------------------------------------------------------------------------
 1 | int[] extractEachKth(int[] a, int k) {
 2 |     int j=0,c=0;
 3 |     for(int i=0;i<a.length;i++){
 4 |         if((i+1)%k!=0){
 5 |            c++;
 6 |         }
 7 |     }
 8 |     
 9 |     int [] g=new int[c];
10 |     for(int i=0;i<a.length;i++){
11 |         if((i+1)%k!=0){
12 |             g[j]=a[i];
13 |             j++;
14 |         }
15 |     }
16 |     return g;   
17 | }
18 | 
19 | 
20 |                                 (or)
21 | 
22 | 
23 | int[] extractEachKth(int[] a, int k) {
24 |     ArrayList <Integer> rg= new ArrayList<Integer>();
25 |     for(int i=0;i<a.length;i++){
26 |         if((i+1)%k!=0){
27 |             rg.add(a[i]);
28 |         }
29 |     }
30 |     int[] r=new int[rg.size()];
31 |     for(int i=0;i<rg.size();i++)
32 |         r[i]=rg.get(i);
33 |     return r;   
34 | }


--------------------------------------------------------------------------------
/CodeSignal/stringsRearrangement.java:
--------------------------------------------------------------------------------
 1 | boolean flag;
 2 | 
 3 | 	boolean check(String s1, String s2) {
 4 | 	    int counter = 0;
 5 | 	   
 6 | 	    for(int i = 0; i < s1.length(); i++)
 7 | 	        if(s1.charAt(i) != s2.charAt(i)) counter++;
 8 | 	    
 9 | 	    return counter == 1;
10 | 	}
11 | 
12 | 	void permute(String[] arr, int l, int h) {
13 | 	    if(l == h) {
14 | 	        flag = true;
15 | 	        for(int i = 0; i < arr.length - 1; i++)
16 | 	            if(!check(arr[i], arr[i + 1])) {
17 | 	                flag = false;
18 | 	                break;
19 | 	            }
20 | 	    }
21 | 	    else {
22 | 	        for(int i = l; i <= h && !flag; i++) {
23 | 	            swap(arr, l, i);
24 | 	            permute(arr, l + 1, h);
25 | 	            swap(arr, l, i);
26 | 	        }
27 | 	    }
28 | 	}
29 | 
30 | 	void swap(String[] arr, int i, int j) {
31 | 	    String tmp = arr[i];
32 | 	    arr[i] = arr[j];
33 | 	    arr[j] = tmp;
34 | 	}
35 | 
36 | 	boolean stringsRearrangement(String[] inputArray) {
37 | 	    permute(inputArray, 0, inputArray.length - 1);
38 | 	    return flag;
39 | 	}
40 | 


--------------------------------------------------------------------------------
/CodeSignal/Minesweeper.java:
--------------------------------------------------------------------------------
 1 | int[][] minesweeper(boolean[][] matrix) {
 2 |     int[][] out = new int[matrix.length][matrix[0].length];
 3 |     for (int i = 0; i < matrix.length; i++) {
 4 |         for (int j = 0; j < matrix[0].length; j++) {
 5 |             if (matrix[i][j] == true) {
 6 |                 try {
 7 |                     out[i][j-1]++;
 8 |                 }catch (Exception e) {}
 9 |                 try {
10 |                     out[i][j+1]++;
11 |                 }catch (Exception e) {}
12 |                 try {
13 |                     out[i-1][j]++;
14 |                 }catch (Exception e) {}
15 |                 try {
16 |                     out[i+1][j]++;
17 |                 }catch (Exception e) {}
18 |                 try {
19 |                     out[i-1][j-1]++;
20 |                 }catch (Exception e) {}
21 |                 try {
22 |                     out[i-1][j+1]++;
23 |                 }catch (Exception e) {}
24 |                 try {
25 |                     out[i+1][j-1]++;
26 |                 }catch (Exception e) {}
27 |                 try {
28 |                     out[i+1][j+1]++;
29 |                 } catch (Exception e) {}
30 |             }
31 |         }
32 |     }
33 |     return out;
34 | }
35 | 


--------------------------------------------------------------------------------