import java.util.Scanner;

public class EchoName
{
    public static void main(final String[] args)
    {
        final Scanner scan = new Scanner(System.in);

        System.out.println("Geben sie ihren Namen ein: ");
        final String[] name = scan.nextLine().split(" ");

        name[name.length - 1] = name[name.length - 1].toUpperCase();

        for (int i = 0; i < name.length; i++)
        {
            System.out.print(name[i]);

            if (i < (name.length - 1))
            {
                System.out.print(" ");
            }
        }

        // Damit am Ende der Ausgabe ein Zeilenumbruch erzeugt wird
        // Nur interessant falls noch weiterer Text ausgegeben wird
        System.out.println();
    }
}

import java.util.Scanner;

public class Main
{

	protected static enum NameStates {
		FIRST_NAME, LAST_NAME
	}

    public static void main(final String[] args)
    {
        final Scanner scan = new Scanner(System.in);

        System.out.println("Geben sie ihren Namen ein: ");
        String name = scan.nextLine();
        
        int nameLength = name.length();
        
        String output = "";
        
        String name2 = name.substring(0, name.length());
        
        int lastNameFrom = 0;
        
        //do not capitalize middle names
        int i = 0;
        while (true) {
        	try {
        		char currentLetter = name2.charAt(0);
        		if (currentLetter == ' ') {
        			lastNameFrom = i;
        		}
        		name2 = name2.split("^.")[1];
        	} catch (IndexOutOfBoundsException e) {
        		break;
        	}
        	i++;
        }

        NameStates currentState = NameStates.FIRST_NAME;

        while (true) {
    		char currentLetter = name.charAt(0);
    		if (name.length() < nameLength - lastNameFrom) {
    			currentState = NameStates.LAST_NAME;
    		}
    		//TODO add support for non-ascii characters
    		if (currentState == NameStates.LAST_NAME && currentLetter > 0x60 && currentLetter < 0x7b) {
    			currentLetter -= ' ';
    		}
    		output = output.concat(String.valueOf(currentLetter));
        	if (name.hashCode() > 0 && name.hashCode() < 0xff) {
        		break;
        	}
        	String[] cutFirstCharacter =name.split(".", 2); 
    		name = cutFirstCharacter[cutFirstCharacter.length - 1];
        }
        
        System.out.println(output);
        
        scan.close();

    }

}

import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class parser {
	public abstract static class p {
		public abstract result parse(String s);
	}
	
	public static class result {
		public boolean success;
		public String left, right;
		
		public result(boolean success) {
			this.success = success;
			left = null;
			right = null;
		}
		
		public result(boolean success, String left, String right) {
			this.success = success;
			this.left = left;
			this.right = right;
		}
	}
	
	public static class single extends p {
		private char c;
		
		public single(char c) {
			this.c = c;
		}
		
		public result parse(String s) {
			if (s.length() > 0 && s.charAt(0) == c) {
				return new result(true, Character.toString(c), s.substring(1));
			} else {
				return new result(false);
			}
		}
	}
	
	public static class any extends p {
		private List<Character> c;
		
		public any(Character[] c) {
			this.c = Arrays.asList(c);
		}
		
		public result parse(String s) {
			if (s.length() > 0 && c.contains(s.charAt(0))) {
				return new result(true, Character.toString(s.charAt(0)), s.substring(1));
			} else {
				return new result(false);
			}
		}		
	}
	
	public static class combine extends p {
		private p left, right;
		
		public combine(p left, p right) {
			this.left = left;
			this.right = right;
		}
		
		public result parse(String s) {
			result r = left.parse(s);
			if (r.success) {
				result r2 = right.parse(r.right);
				if (r2.success) {
					return new result(true, r.left + r2.left, r2.right);
				}
			}
			
			return new result(false);
		}		
	}
	
	public static class repeat extends p {
		private p inner;
		
		public repeat(p inner) {
			this.inner = inner;
		}
		
		public result parse(String s) {
			result r = inner.parse(s);
			if (r.success) {
				result r2 = this.parse(r.right);
				if (r2.success) {
					return new result(true, r.left + r2.left, r2.right);
				} else {
					return new result(true, r.left, r.right);
				}
			}
			
			return new result(false);
		}
	}
	
	public static void main(String[] args) {
		Character[] alphas = new Character[] {
			'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
			'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
			'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
			'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
		};
		String s = new Scanner(System.in).nextLine();
		
		p alpha = new repeat(new any(alphas));
		p space = new single(' ');
		p name = new combine(alpha, new combine(space, alpha));
		
		if (name.parse(s).success) {			
			String first = alpha.parse(s).left;
			String last = alpha.parse(space.parse(alpha.parse(s).right).right).left;
			
			System.out.printf("%s %s", first.toLowerCase(), last.toUpperCase());
		}
	}
}

Root1
-- Child1
-- -- Child2
-- Child3
Root2
-- Child4
-- Child5
-- -- Child6
-- -- -- Child7