SHARE
TWEET

Untitled

a guest Jun 19th, 2019 62 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import java.util.Random;
  2.  
  3. public class Ala {
  4.     public static void main(String[] args) {
  5.         Random randomGenerator = new Random();
  6.         char[][] arr = new char[50][50];
  7.         for (int i = 0; i < arr.length; i++) {
  8.             for (int j = 0; j < arr[i].length; j++) {
  9.                 arr[i][j] = (char) (randomGenerator.nextInt(26)+97);
  10.             }
  11.         }
  12.         for (int i = 0; i < arr.length; i++) {
  13.                 System.out.printf("%-3d", i);
  14.         }
  15.         System.out.println();
  16.         for (int i = 0; i < arr.length; i++) {
  17.             for (int j = 0; j < arr[i].length; j++) {
  18.                 System.out.print(arr[i][j]+"  ");
  19.             }
  20.             System.out.println();
  21.         }
  22.         boolean ala = false;
  23.         for (int i = 0; i < arr.length; i++) {
  24.             for (int j = 0; j < arr[i].length; j++) {
  25.                 if (j>1) {
  26.                     if (arr[i][j] == 'a' && arr[i][j - 1] == 'l' && arr[i][j - 2] == 'a') {//left
  27.                         ala = true;
  28.                         System.out.println(i + " " + j);
  29.                     }
  30.                 }
  31.                 if (j<arr[i].length-2) {
  32.                     if (arr[i][j] == 'a' && arr[i][j + 1] == 'l' && arr[i][j + 2] == 'a') {//rigth
  33.                         ala = true;
  34.                         System.out.println(i + " " + j);
  35.                     }
  36.                 }
  37.                 if (i<arr.length-2) {
  38.                     if (arr[i][j] == 'a' && arr[i + 1][j] == 'l' && arr[i + 2][j] == 'a') {//bot
  39.                         ala = true;
  40.                         System.out.println(i + " " + j);
  41.                     }
  42.                 }
  43.                 if (i>1) {
  44.                     if (arr[i][j] == 'a' && arr[i-1][j] == 'l' && arr[i - 2][j] == 'a') {//top
  45.                         ala = true;
  46.                         System.out.println(i + " " + j);
  47.                     }
  48.                 }
  49.                 if (i<arr.length-2 && j<arr[i].length-2) {
  50.                     if (arr[i][j] == 'a' && arr[i + 1][j + 1] == 'l' && arr[i + 2][j + 2] == 'a') {//bot&rigth
  51.                         ala = true;
  52.                         System.out.println(i + " " + j);
  53.                     }
  54.                 }
  55.                 if (i>1 && j>1) {
  56.                     if (arr[i][j] == 'a' && arr[i - 1][j - 1] == 'l' && arr[i - 2][j - 2] == 'a') {//top&left
  57.                         ala = true;
  58.                         System.out.println(i + " " + j);
  59.                     }
  60.                 }
  61.                 if (i>1 && j<arr[i].length-2) {
  62.                     if (arr[i][j] == 'a' && arr[i - 1][j + 1] == 'l' && arr[i - 2][j + 2] == 'a') {//top&rigth
  63.                         ala = true;
  64.                         System.out.println(i + " " + j);
  65.                     }
  66.                 }
  67.                 if (i<arr.length-2 && j>1) {
  68.                     if (arr[i][j] == 'a' && arr[i + 1][j - 1] == 'l' && arr[i + 2][j - 2] == 'a') {//bot&left
  69.                         ala = true;
  70.                         System.out.println(i + " " + j);
  71.                     }
  72.                 }
  73.             }
  74.         }
  75.         System.out.println(ala);
  76.     }
  77. }
  78.      
  79. public static boolean contains(char[][] grid, String word) {
  80.  
  81. }
  82.      
  83. public static boolean contains(char[][] grid, String word) {
  84.     return verticalContains(grid, word)
  85.             || horizontalContains(grid, word)
  86.             || diagonalContains(grid, word);
  87. }
  88.      
  89. private static boolean verticalContains(char[][] grid, String word) {
  90.     for (char[] row : grid) {
  91.         if (new String(row).contains(word)) {
  92.             return true;
  93.         }
  94.     }
  95.     return false;
  96. }
  97.  
  98. private static boolean horizontalContains(char[][] grid, String word) {
  99.     int wordLength = word.length();
  100.     int max = grid.length - wordLength;
  101.     char[] wordArray = word.toCharArray();
  102.     for (int i = 0, length = grid[0].length; i < length; i++) {
  103.         loop: for (int j = 0; j < max; j++) {
  104.             for (int k = j; k < wordArray.length; k++) {
  105.                 if (wordArray[k - j] != grid[k][i]) {
  106.                     continue loop;
  107.                 }
  108.             }
  109.             return true;
  110.         }
  111.     }
  112. }
  113.      
  114. private static boolean diagonalContains(char[][] grid, String word) {
  115.     int wordLength = word.length();
  116.     char[] wordArray = word.toCharArray();
  117.     for (int i = 0, length = grid.length; i < length; i++) {
  118.         loop: for (int j = 0, k = i, subLength = grid[i].length;
  119.                 j < subLength && k >= wordLength; j++, k--) {
  120.             for (int l = 0; l < wordLength; l++) {
  121.                 if (grid[j + l][k - l] != wordArray[l]) {
  122.                     continue loop;
  123.                 }
  124.                 return true;
  125.             }
  126.         }
  127.     }
  128. }
  129.      
  130. import java.util.Arrays;
  131.  
  132. public class CharGrid {
  133.  
  134.     private final char[][] grid;
  135.  
  136.     public CharGrid(char[][] grid) {
  137.         int length = grid.length;
  138.         this.grid = copyArray(grid);
  139.     }
  140.  
  141.     public char[][] getGrid() {
  142.         return copyArray(grid)
  143.     }
  144.  
  145.     private char[][] copyArray(char[][] array) {
  146.         char[][] result = Arrays.copy(array, length);
  147.         for (int i = 0; i < length; i++) {
  148.             result[i] = Arrays.copy(array[i], array[i].length);
  149.         }
  150.         return result;
  151.     }
  152.  
  153.     public boolean contains(String word) {
  154.         return verticalContains(grid, word)
  155.                 || horizontalContains(grid, word)
  156.                 || diagonalContains(grid, word);
  157.     }
  158.  
  159.     private boolean verticalContains(String word) {
  160.         for (char[] row : grid) {
  161.             if (new String(row).contains(word)) {
  162.                 return true;
  163.             }
  164.         }
  165.         return false;
  166.     }
  167.  
  168.     private boolean horizontalContains(String word) {
  169.         int wordLength = word.length();
  170.         int max = grid.length - wordLength;
  171.         char[] wordArray = word.toCharArray();
  172.         for (int i = 0, length = grid[0].length; i < length; i++) {
  173.             loop: for (int j = 0; j < max; j++) {
  174.                 for (int k = j; k < wordArray.length; k++) {
  175.                     if (wordArray[k - j] != grid[k][i]) {
  176.                         continue loop;
  177.                     }
  178.                 }
  179.                 return true;
  180.             }
  181.         }
  182.     }
  183.  
  184.     private boolean diagonalContains(String word) {
  185.         int wordLength = word.length();
  186.         char[] wordArray = word.toCharArray();
  187.         for (int i = 0, length = grid.length; i < length; i++) {
  188.             loop: for (int j = 0, k = i, subLength = grid[i].length;
  189.                     j < subLength && k >= wordLength; j++, k--) {
  190.                 for (int l = 0; l < wordLength; l++) {
  191.                     if (grid[j + l][k - l] != wordArray[l]) {
  192.                         continue loop;
  193.                     }
  194.                     return true;
  195.                 }
  196.             }
  197.         }
  198.     }
  199.  
  200. }
  201.      
  202. class WordGrid {
  203.   public contains(String word) {
  204.     return any(word in row for row in getRows())                ||
  205.            any(word in column for column in getColumns())       ||
  206.            any(word in diagonal for diagonal in getDiagonals())
  207.    }
  208. }
  209.      
  210. for(i=0;i<arr.length;i++) {
  211.         for(j=0;j<arr.length;j++) {`enter code here`
  212.             horizontal = horizontal+""+arr[i][j];
  213.             vertical = vertical +""+arr[j][i];
  214.             if(i==j)
  215.                 diagonal = diagonal+""+arr[i][j];
  216.         }
  217.         horizontal = horizontal +" ";
  218.         vertical = vertical +" ";
  219.     }
  220.     System.out.println("horizontal String : "+horizontal);
  221.     System.out.println(horizontal.contains(searchString));
  222.     System.out.println("vertical String : "+vertical);
  223.     System.out.println(vertical.contains(searchString));
  224.     System.out.println("diagonal String : "+diagonal);
  225.     System.out.println(diagonal.contains(searchString));
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top