CareerCup

Java solution using DFS (Depth First Search). In graph node is an index in initial array. One node is connected to some other one if the last letter equals to first letter of the second word. First we build a graph, and then run DFS starting from each node. If at some point we visit all nodes while traversing the graph, it means we found the solution.

import java.util.*;
import java.io.*;

public class Solution {
    int num;
    int total; // total number of words
    boolean found;
    boolean[] used; // used[i] - if we used i-th word
    List<Integer> result = new ArrayList<>(); // list of resulted strings
    Map<Integer, List<Integer>> g = new HashMap<>(); // n -> list of connected nodes

    public static void main(String[] args) {
        new Solution().solve();
    }

    public void solve() {
        PrintWriter out = new PrintWriter(System.out);
        String[] words = {"Luis", "Hector", "Selena", "Emmanuel", "Amish"};
        buildTailedStrings(words);

        if (found)
            for (int i : result)
                out.println(words[i]);
        else
            out.println("No solution found");

        out.close();
    }

    public void connectWordNodes(int ind1, int ind2, String w1, String w2) {
        // w2 can continue w1 (w1 --> w2)
        if (w1.toUpperCase().charAt(w1.length() - 1) == w2.toUpperCase().charAt(0)) {
            if (!g.containsKey(ind1))
                g.put(ind1, new ArrayList<>());
            g.get(ind1).add(ind2);
        }

        // w1 can continue w2 (w2 --> w1)
        if (w2.toUpperCase().charAt(w2.length() - 1) == w1.toUpperCase().charAt(0)) {
            if (!g.containsKey(ind2))
                g.put(ind2, new ArrayList<>());
            g.get(ind2).add(ind1);
        }
    }

    public void buildTailedStrings(String[] words) {
        // Build graph
        for (int i = 0; i < words.length - 1; i++)
            for (int j = i + 1; j < words.length; j++) {
                String w1 = words[i];
                String w2 = words[j];

                connectWordNodes(i, j, w1, w2);
            }

        found = false;
        total = words.length;
        used = new boolean[words.length];

        // Run dfs from each node
        for (int i = 0; i < words.length; i++) {
            num = 0;
            dfs(i);
            if (found)
                break;
        }
    }

    public void dfs(int node) {
        num++;
        used[node] = true;
        result.add(node);

        // if we reach to the point where we have all nodes, return result
        if (num == total) {
            found = true;
            return;
        }

        if (g.containsKey(node)) {
            List<Integer> nodesList = g.get(node);
            for (int curNode : nodesList) {
                if (!used[curNode])
                    dfs(curNode);
            }
        }

        if (found)
            return;

        num--;
        used[node] = false;
        result.remove(result.size() - 1);
    }
}

but set(A) will exclude duplicates

Easy to read, simple and effective Java solution using Set:

public List<Integer> intersectArrays(int[] a, int[] b) {
    Map<Integer, Integer> map = new HashMap<>(); // number of appearances
    List<Integer> result = new ArrayList<>();

    for (int i = 0; i < a.length; i++) {
        int curNum = 1;
        if (map.containsKey(a[i]))
            curNum = map.get(a[i]) + 1;

        map.put(a[i], curNum);
    }

    for (int i = 0; i < b.length; i++) {
        if (!map.containsKey(b[i]))
            continue;

        int curNum = map.get(b[i]);
        if (curNum > 0) {
            curNum--;
            result.add(b[i]);
        }

        map.put(b[i], curNum); // update decreased counter
    }

    return result;
}

Simple and effective Java solution using while loop:

public String charFrequency(String s) {
    String res = "";
    int ind = 0;
    while (ind < s.length()) {
        char cur = s.charAt(ind);
        int num = 1;
        while (ind < s.length() - 1 && cur == s.charAt(ind + 1)) {
            ind++;
            num++;
        }
        ind++;
        res += String.format("%s%s", cur, num);
    }
    return res;
}

Effective Java solution using ArrayDeque

import java.util.*;
import java.io.*;

public class Solution {

    public static void main(String[] args) {
        new Solution().solve();
    }

    public boolean isCorrectBracketExpression(String s) {
        ArrayDeque<Character> q = new ArrayDeque<>();
        String brackets = "({<[)}>]";

        for (Character cur : s.toCharArray()) {
            if (brackets.indexOf(cur) < 4)
                q.addFirst(cur);
            else {
                if (q.size() > 0) {
                    if (brackets.charAt(brackets.indexOf(q.peek()) + 4) == cur)
                        q.poll();
                    else
                        return false;
                } else // nothing in the queue, but we want to add something, incorrect expression
                    return false;
            }
        }

        return q.size() == 0;
    }

    public void solve() {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        String s = in.nextLine();
        out.print(isCorrectBracketExpression(s) ? "Correct" : "Incorrect");
        out.close();
    }
}

Effective Java solution using HashSet

import java.util.*;
import java.io.*;

public class Solution {

    public static void main(String[] args) {
        new Solution().solve();
    }

    public void solve() {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int[] a = {3, 1, 4, 5, 19, 6};
        int[] b = {14, 9, 22, 36, 8, 0, 64, 25};

        List<Integer> result = findSquares(a, b);

        for (int cur : result)
            out.println(cur);

        out.close();
    }

    // search a[i]^2 in b
    public List<Integer> findSquares(int[] a, int[] b) {
        List<Integer> result = new ArrayList<>();
        Set<Integer> squares = new HashSet<>();
        for (int i = 0; i < a.length; i++)
            squares.add(a[i] * a[i]);

        for (int i = 0; i < b.length; i++)
            if (squares.contains(b[i]))
                result.add(b[i]);

        return result;
    }
}

Complete Java solution with considering different edge cases

import java.util.*;
import java.io.*;

public class Solution {

    /*
    Smart string is a string no longer than 30 character with cut no words
     */

    public static void main(String[] args) {
        new Solution().solve();
    }

    public void solve() {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        String s = in.nextLine();
        String res = s;
        int maxLen = 10;
        int firstSpace = s.indexOf(" "); // whole sentence is one word and it's longer than max allowed

        if (firstSpace > maxLen)
            res = "";
        else if (s.length() > maxLen) {
            String cutStr = s.substring(0, maxLen);
            res = cutStr.substring(0, Math.max(cutStr.lastIndexOf(" "), cutStr.length()));
        }

        out.print(res);
        out.close();
    }
}