Final Fantasy

public class Solution { public List fizzBuzz(int n) { List numList = new ArrayList(); for (int i = 1; i <= n; i++) { if ((i % 15) == 0) numList.add("FizzBuzz"); else if ((i % 3) ==

public class Solution { public String reverseString(String s) { char tmp[] = s.toCharArray(); int l = tmp.length; for(int i = 0; i < l / 2; i++) { char t = tmp[l - i - 1]; tmp[l

public class Solution { public boolean canWinNim(int n) { return ((n % 4) != 0); }}

public class Solution { public int singleNumber(int[] nums) { int singleNum = 0; for (int i = 0; i < nums.length; i++) singleNum ^= nums[i]; return singleNum; }}

public class Solution { public int getSum(int a, int b) { int c = (a & b) << 1; int d = a ^ b; while (c != 0) { int tmp = d; d = d ^ c; c = (c & tmp) <

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public class Solution {

public class Solution { public int addDigits(int num) { return (num % 9 == 0) && num != 0 ? 9 : num % 9; }}

public class Solution { public char findTheDifference(String s, String t) { char[] sToChars = s.toCharArray(); char[] tToChars = t.toCharArray(); char r = '\0'; for

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public class Solution {

public class Solution { public void moveZeroes(int[] nums) { if (nums.length <= 1) return; int count = 0; for (int i = 0; i < nums.length; i++) { if (nums[i] == 0) count++;

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public class Solution {

public class Solution { public boolean canConstruct(String ransomNote, String magazine) { char[] r = ransomNote.toCharArray(); char[] m = magazine.toCharArray(); int rl = r

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */public class Solution { public void deleteNo

public class Solution { public int[] intersection(int[] nums1, int[] nums2) { if (nums1 == null || nums2 == null) return null; Set set1 = new HashSet(); Set set2 = new Hash

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public class Solution {

public class Solution { public int titleToNumber(String s) { if (s == "") return 0; char[] c = s.toCharArray(); int r = 0; for (int i = 0; i < c.length; i++) { r += (c

public class Solution { public int firstUniqChar(String s) { char[] c = s.toCharArray(); Map map = new HashMap(); for (int i =0; i < c.length; i++) { if (!map.cont

public class Solution { public boolean isAnagram(String s, String t) { if (s == "" && t == "") return true; else if (s.length() != t.length()) return false; Map map = new H

public class Solution { public int majorityElement(int[] nums) { Map map = new HashMap(); for (int i = 0; i < nums.length; i++) { if (!map.containsKey(nums[i])) map.put(nu

public class Solution { public int longestPalindrome(String s) { int[] c = new int[52]; for (int i = 0; i < s.length(); i++) { if (s.charAt(i) <= 'Z') c[s.charAt(i) - 'A']

public class Solution { public List readBinaryWatch(int num) { List r = new ArrayList(); if (num == 0) { r.add("0:00"); return r; } else if (num > 10) ret

public class Solution { public boolean containsDuplicate(int[] nums) { Arrays.sort(nums); for (int i = 1; i < nums.length; i++) { if(nums[i] == nums[i - 1]) {

public class Solution { public int[] intersect(int[] nums1, int[] nums2) { if (nums1.length == 0 || nums2.length == 0) return new int[0]; Arrays.sort(nums1); Arrays.sort(nu

public class Solution { public int romanToInt(String s) { int r = 0; int tmp = 0; for (int i = s.length() - 1; i >= 0; i--) { int n = 0; char c = s.charAt(i);

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */public class Solution { public ListNode reve

public class Solution { public String addStrings(String num1, String num2) { int l1 = num1.length(); int l2 = num2.length(); int c = 0; String sum = ""; for

public class Solution { public String toHex(int num) { if (num == 0) return "0"; StringBuilder hex = new StringBuilder(); boolean isNegative = false; if (num < 0) { is

public class Solution { public boolean isPowerOfThree(int n) { return n 0 ? false : true); }}

public class Solution { public boolean isPowerOfTwo(int n) { return n <= 0 ? false : (Integer.bitCount(n) == 1 ? true : false); }}

public class Solution { public boolean isHappy(int n) { List<Integer> list = new ArrayList<Integer>(); while (!list.contains(n)) { list.add(n); int tmp = 0; int l = String.valueOf(n).length(); for (in

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */public class Solution { public ListNode dele

public class Solution { public int climbStairs(int n) { if (n <= 3) return n; int[] stairs = new int[n]; stairs[0] = 1; stairs[1] = 2; stairs[2] = 3; for (int i = 3

public class Solution { // you need to treat n as an unsigned value public int hammingWeight(int n) { return Integer.bitCount(n); }}

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public class Solution {

public class Solution { public boolean isUgly(int num) { if (num == 1) return true; else if (num < 1) return false; while (num != 1) { if (num % 2 == 0) {

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public class Solution {

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */public class Solution { public ListNode merg

public class Solution { public int arrangeCoins(int n) { int count = 0; while (n >= (count + 1)) { count++; n -= count; } return count; }}

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public class Solution { public List<List<Integer>> levelOrderBottom(TreeNode

public class Solution { public boolean wordPattern(String pattern, String str) { String[] p = new String[26]; String[] s = str.split(" "); if (pattern.length() != s.length)