linzhp

def max a, b
  diff = a - b
  [b, a][(diff / diff.abs + 1) / 2]
end

linzhp

describe('A jquery element', function() {
	it('should invoke handlers in the order of events triggered from it', function() {
		var tokens = [];
		var elem = document.createElement('div');
		function e1Handler1(payload) {
			tokens.push('e1Handler1');
			$(elem).trigger('Event2');
		}
		function e1Handler2(payload) {tokens.push('e1Handler2');}
		function e2Handler1(payload) {tokens.push('e2Handler1');}

linzhp

public class Solution {
    /*
    Special cases:
    * A.length == 0 && B.length == 0
    * A.length != 0 && B.length == 0
    * A.length == 1 && B.length == 1
    
    [2], [1,3,4]
    */
    public double findMedianSortedArrays(int A[], int B[]) {

linzhp

public class Solution {
    public int lengthOfLongestSubstring(String s) {
        // Start typing your Java solution below
        // DO NOT write main() function
        String longest = "";
        for(int i = 0; i < s.length(); i++) {
            HashSet<Character> set = new HashSet<Character>();
            set.add(s.charAt(i));
            int j;
            for(j = i + 1; j < s.length(); j++) {

linzhp

public class Solution {
    public int lengthOfLongestSubstring(String s) {
        // Start typing your Java solution below
        // DO NOT write main() function
        String longest = "";
        int i = 0;
        while(i < s.length()) {
            HashMap<Character, Integer> map = new HashMap<Character, Integer>();
            map.put(s.charAt(i), i);
            int j;

linzhp

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

linzhp

public class Solution {
    public String longestPalindrome(String s) {
        // Start typing your Java solution below
        // DO NOT write main() function
        String longest = "";
        for(int i = 0; i < s.length(); i++) {
            int j;
            // pivot at a char
            for(j = 1; i - j >=0 && i + j < s.length(); j++) {
                if(s.charAt(i - j) != s.charAt(i + j)) {

linzhp

var exec  = require('child_process').exec;
var mongoose = require('mongoose');

desc('Runs the mocha unit tests');
task('test', function(params) {
  var proc = exec('mocha --recursive --colors');
  proc.stdout.pipe(process.stdout, { end: false });
  proc.stderr.pipe(process.stderr, { end: false });
  proc.on('exit', process.exit);
});

linzhp

"""
array anagramBuckets(array strings)

Write a function to group an array of strings by anagrams.

Input: An array of strings (possibly with duplicates)
Output: An array of arrays.  Each array contains a set of strings from the input array that are anagrams of each other.  The output should not contain any duplicates.

Example:
Input: ('abc', 'bac', 'xyz', 'xyz')

linzhp

public class Solution {
    private HashMap<String, Boolean> palindromeCache;
    private HashMap<String, Integer> resultCache;
    public int minCut(String s) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        palindromeCache = new HashMap<String, Boolean>();
        resultCache = new HashMap<String, Integer>();
        return minCutRecursive(s);
    }