java常见算法

1.题目

来自(50条消息) java P1101 单词方阵_아름다운 밤的博客-CSDN博客

给一n \times nn×n的字母方阵，内可能蕴含多个“yizhong”单词。单词在方阵中是沿着同一方向连续摆放的。摆放可沿着 88 个方向的任一方向，同一单词摆放时不再改变方向，单词与单词之间可以交叉,因此有可能共用字母。输出时，将不是单词的字母用*代替，以突出显示单词。例如：

输入：
    8                     输出：
    qyizhong              *yizhong
    gydthkjy              gy******
    nwidghji              n*i*****
    orbzsfgz              o**z****
    hhgrhwth              h***h***
    zzzzzozo              z****o**
    iwdfrgng              i*****n*
    yyyygggg              y******g

import java.util.Scanner;

public class aaa {

     static char[][] arr = new char[110][110];
     static char[][] brr = new char[110][110];
     static String test = "yizhong";
     static int[] dx = {1,1,1,0,0,-1,-1,-1}; // 1 表示向右 一格 0 表示不变 -1 表示向左 一格
     static int[] dy = {1,0,-1,1,-1,1,-1,0}; // 0 表示不变 -1 表示向下， 1 表示向上
     static int n ;
     public static void main(String[] args) {

          Scanner scanner = new Scanner(System.in);
          n = scanner.nextInt();

          for (int i = 1; i <= n; i++) {

               String a = scanner.next();
               for(int j = 1;j <= n;j++) {

                    arr[i][j] = a.charAt(j-1);
               }
          }

          for (int i = 1; i <= n; i++) {
               for (int j = 1; j <= n; j++) {

                    if (arr[i][j] == 'y') {

                         dfs(i,j);
                    }
               }
          }

          for (int i = 1; i <= n; i++) {


               for (int j = 1; j <= n; j++) {

                    if (brr[i][j] == 0)
                         brr[i][j] = '*';
                    System.out.print(brr[i][j]);
               }
               System.out.println();
          }
     }

     public static void dfs(int x,int y) {

          for (int i = 0; i < 8; i++) {

               int flag = 1;
               for (int j = 1; j <= 6; j++) {
                    int nx = j*dx[i]+x;
                    int ny = j*dy[i]+y;
                    if (nx < 1 || ny < 1 || nx > n || ny > n) {
                         flag = 0;
                         break;
                    }

                    if (test.charAt(j) != arr[nx][ny]) {
                         flag = 0;
                    }
               }
               if (flag == 0)
                    continue;

               for (int j = 0; j <= 6; j++) {
                    int nx = x + j*dx[i];
                    int ny = y + j*dy[i];

                    brr[nx][ny] = arr[nx][ny];
               }
          }
     }
}

2.题目

给你两个二进制字符串，返回它们的和（用二进制表示）。

输入为 非空 字符串且只包含数字 1 和 0。

示例 1:

输入: a = "11", b = "1"
输出: "100"
示例 2:

输入: a = "1010", b = "1011"
输出: "10101"

class Solution {
    public String addBinary(String a, String b) {
        StringBuffer ans = new StringBuffer();

        int n = Math.max(a.length(), b.length()), carry = 0;
        for (int i = 0; i < n; ++i) {
            carry += i < a.length() ? (a.charAt(a.length() - 1 - i) - '0') : 0;
            carry += i < b.length() ? (b.charAt(b.length() - 1 - i) - '0') : 0;
            ans.append((char) (carry % 2 + '0'));
            carry /= 2;
        }

        if (carry > 0) {
            ans.append('1');
        }
        ans.reverse();

        return ans.toString();
    }
}

3.题目

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

说明：本题中，我们将空字符串定义为有效的回文串。

示例 1:

输入: "A man, a plan, a canal: Panama"
输出: true
解释："amanaplanacanalpanama" 是回文串
示例 2:

输入: "race a car"
输出: false
解释："raceacar" 不是回文串

class Solution {
     public boolean isPalindrome(String s) {
          int len = s.length();

          StringBuffer buffer = new StringBuffer();

          for (int i = 0; i < len; i++) {

               char a = s.charAt(i);
               if (Character.isLetterOrDigit(a))
                    buffer.append(a);
          }

          int n = buffer.length();

          int left = 0;
          int right = n - 1;

          while (left < right) {

               if (Character.toLowerCase(buffer.charAt(left)) != Character.toLowerCase(buffer.charAt(right)) )
                    return false;

               left++;
               right--;
          }
          return true;
     }
}