package template;

import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

public class TestCase {

    private boolean isSolved;
    private Object solution;
    private Map<String, Integer> intProperties;
    private Map<String, ArrayList<Integer>> intArrayProperties;
    private Map<String, ArrayList<ArrayList<Integer>>> intArray2DProperties;
    private Map<String, Double> doubleProperties;
    private Map<String, ArrayList<Double>> doubleArrayProperties;
    private Map<String, ArrayList<ArrayList<Double>>> doubleArray2DProperties;
    private Map<String, String> stringProperties;
    private Map<String, ArrayList<String>> stringArrayProperties;
    private Map<String, ArrayList<ArrayList<String>>> stringArray2DProperties;
    private Map<String, Boolean> booleanProperties;
    private Map<String, ArrayList<Boolean>> booleanArrayProperties;
    private Map<String, ArrayList<ArrayList<Boolean>>> booleanArray2DProperties;
    private Map<String, Long> longProperties;
    private Map<String, ArrayList<Long>> longArrayProperties;
    private Map<String, ArrayList<ArrayList<Long>>> longArray2DProperties;
    private int ref;
    private double time;

    public TestCase() {
        initialise();
    }

    private void initialise() {
        isSolved = false;
        intProperties = new HashMap<>();
        intArrayProperties = new HashMap<>();
        intArray2DProperties = new HashMap<>();
        doubleProperties = new HashMap<>();
        doubleArrayProperties = new HashMap<>();
        doubleArray2DProperties = new HashMap<>();
        stringProperties = new HashMap<>();
        stringArrayProperties = new HashMap<>();
        stringArray2DProperties = new HashMap<>();
        booleanProperties = new HashMap<>();
        booleanArrayProperties = new HashMap<>();
        booleanArray2DProperties = new HashMap<>();
        longProperties = new HashMap<>();
        longArrayProperties = new HashMap<>();
        longArray2DProperties = new HashMap<>();
        ref = 0;
    }

    public void setSolution(Object o) {
        solution = o;
        isSolved = true;
    }
    
    public Object getSolution() {
        if (!isSolved) {
            Utils.die("getSolution on unsolved testcase");
        }

        return solution;
    }

    public void setRef(int i) {
        ref = i;
    }
    public int getRef() {
        return ref;
    }

    public void setTime(double d) {
        time = d;
    }
    public double getTime() {
        return time;
    }
    
    public void setInteger(String s, Integer i) {
        intProperties.put(s, i);
    }
    
    public Integer getInteger(String s) {
        return intProperties.get(s);
    }

    public void setIntegerList(String s, ArrayList<Integer> l) {
        intArrayProperties.put(s, l);
    }

    public void setIntegerMatrix(String s, ArrayList<ArrayList<Integer>> l) {
        intArray2DProperties.put(s, l);
    }

    public ArrayList<Integer> getIntegerList(String s) {
        return intArrayProperties.get(s);
    }

    public Integer getIntegerListItem(String s, int i) {
        return intArrayProperties.get(s).get(i);
    }

    public ArrayList<ArrayList<Integer>> getIntegerMatrix(String s) {
        return intArray2DProperties.get(s);
    }
    
    public ArrayList<Integer> getIntegerMatrixRow(String s, int row) {
        return intArray2DProperties.get(s).get(row);
    }
    
    public Integer getIntegerMatrixItem(String s, int row, int column) {
        return intArray2DProperties.get(s).get(row).get(column);
    }

    public ArrayList<Integer> getIntegerMatrixColumn(String s, int column) {
        ArrayList<Integer> out = new ArrayList();
        
        for(ArrayList<Integer> row : intArray2DProperties.get(s)) {
            out.add(row.get(column));
        }
        return out;
    }


    public void setDouble(String s, Double i) {
        doubleProperties.put(s, i);
    }
    
    public Double getDouble(String s) {
        return doubleProperties.get(s);
    }

    public void setDoubleList(String s, ArrayList<Double> l) {
        doubleArrayProperties.put(s, l);
    }

    public void setDoubleMatrix(String s, ArrayList<ArrayList<Double>> l) {
        doubleArray2DProperties.put(s, l);
    }

    public ArrayList<Double> getDoubleList(String s) {
        return doubleArrayProperties.get(s);
    }

    public Double getDoubleListItem(String s, int i) {
        return doubleArrayProperties.get(s).get(i);
    }

    public ArrayList<ArrayList<Double>> getDoubleMatrix(String s) {
        return doubleArray2DProperties.get(s);
    }
    
    public ArrayList<Double> getDoubleMatrixRow(String s, int row) {
        return doubleArray2DProperties.get(s).get(row);
    }
    
    public Double getDoubleMatrixItem(String s, int row, int column) {
        return doubleArray2DProperties.get(s).get(row).get(column);
    }

    public ArrayList<Double> getDoubleMatrixColumn(String s, int column) {
        ArrayList<Double> out = new ArrayList();
        
        for(ArrayList<Double> row : doubleArray2DProperties.get(s)) {
            out.add(row.get(column));
        }
        return out;
    }

    
    public void setString(String s, String t) {
        stringProperties.put(s, t);
    }
    
    public String getString(String s) {
        return stringProperties.get(s);
    }

    public void setStringList(String s, ArrayList<String> l) {
        stringArrayProperties.put(s, l);
    }

    public void setStringMatrix(String s, ArrayList<ArrayList<String>> l) {
        stringArray2DProperties.put(s, l);
    }

    public ArrayList<String> getStringList(String s) {
        return stringArrayProperties.get(s);
    }

    public String getStringListItem(String s, int i) {
        return stringArrayProperties.get(s).get(i);
    }

    public ArrayList<ArrayList<String>> getStringMatrix(String s) {
        return stringArray2DProperties.get(s);
    }
    
    public ArrayList<String> getStringMatrixRow(String s, int row) {
        return stringArray2DProperties.get(s).get(row);
    }
    
    public String getStringMatrixItem(String s, int row, int column) {
        return stringArray2DProperties.get(s).get(row).get(column);
    }

    public ArrayList<String> getStringMatrixColumn(String s, int column) {
        ArrayList<String> out = new ArrayList();
        
        for(ArrayList<String> row : stringArray2DProperties.get(s)) {
            out.add(row.get(column));
        }
        return out;
    }

    
    public void setBoolean(String s, Boolean b) {
        booleanProperties.put(s, b);
    }
    
    public Boolean getBoolean(String s) {
        return booleanProperties.get(s);
    }

    public void setBooleanList(String s, ArrayList<Boolean> l) {
        booleanArrayProperties.put(s, l);
    }

    public void setBooleanMatrix(String s, ArrayList<ArrayList<Boolean>> l) {
        booleanArray2DProperties.put(s, l);
    }

    public ArrayList<Boolean> getBooleanList(String s) {
        return booleanArrayProperties.get(s);
    }

    public Boolean getBooleanListItem(String s, int i) {
        return booleanArrayProperties.get(s).get(i);
    }

    public ArrayList<ArrayList<Boolean>> getBooleanMatrix(String s) {
        return booleanArray2DProperties.get(s);
    }
    
    public ArrayList<Boolean> getBooleanMatrixRow(String s, int row) {
        return booleanArray2DProperties.get(s).get(row);
    }
    
    public Boolean getBooleanMatrixItem(String s, int row, int column) {
        return booleanArray2DProperties.get(s).get(row).get(column);
    }

    public ArrayList<Boolean> getBooleanMatrixColumn(String s, int column) {
        ArrayList<Boolean> out = new ArrayList();
        
        for(ArrayList<Boolean> row : booleanArray2DProperties.get(s)) {
            out.add(row.get(column));
        }
        return out;
    }

    public void setLong(String s, Long b) {
        longProperties.put(s, b);
    }
    
    public Long getLong(String s) {
        return longProperties.get(s);
    }

    public void setLongList(String s, ArrayList<Long> l) {
        longArrayProperties.put(s, l);
    }

    public void setLongMatrix(String s, ArrayList<ArrayList<Long>> l) {
        longArray2DProperties.put(s, l);
    }

    public ArrayList<Long> getLongList(String s) {
        return longArrayProperties.get(s);
    }

    public Long getLongListItem(String s, int i) {
        return longArrayProperties.get(s).get(i);
    }

    public ArrayList<ArrayList<Long>> getLongMatrix(String s) {
        return longArray2DProperties.get(s);
    }
    
    public ArrayList<Long> getLongMatrixRow(String s, int row) {
        return longArray2DProperties.get(s).get(row);
    }
    
    public Long getLongMatrixItem(String s, int row, int column) {
        return longArray2DProperties.get(s).get(row).get(column);
    }

    public ArrayList<Long> getLongMatrixColumn(String s, int column) {
        ArrayList<Long> out = new ArrayList();
        
        for(ArrayList<Long> row : longArray2DProperties.get(s)) {
            out.add(row.get(column));
        }
        return out;
    }

    

    


}

package co.rfcasallasm.firstround.dancing;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class Main {

	private static Integer findGooglerAtLeastOrBetter( int surprisingCases, int atLeastThisResult, int totalPoints[] ){
		System.out.println("xxxxxxxxxxxxxxxxxxxx");
		List<List<int[]>> explodedValues = new ArrayList<List<int[]>>();
		for( int i = 0; i < totalPoints.length; i++ ){
			List<int[]> combinations = findCombinations( totalPoints[ i ] );
			for( int[] combination : combinations ){
				System.out.print( combination[ 0 ]+"-"+combination[ 1 ]+"-"+combination[ 2 ]+" " );
			}
			System.out.println("");
			explodedValues.add( combinations );
		}		
		return findMaxValue( explodedValues, 0, surprisingCases, atLeastThisResult );
	}	
	
	private static Integer findMaxValue( List<List<int[]>> explodedValues, int index, int surprisingCases, int atLeastThisResult ){
		if( explodedValues.size() <= index ){
			if( surprisingCases > 0 ){
				return null;
			}
			return 0;
		}
		Integer retValue = null;
		List<int[]> thisValues = explodedValues.get( index );
		for( int[] curCmb : thisValues ){			
			boolean isSurprisingCase = ( (curCmb[ 2 ]-curCmb[ 1 ]) == 2 || (curCmb[ 2 ]-curCmb[ 0 ]) == 2 || (curCmb[ 1 ]-curCmb[ 0 ]) == 2);			
			if( !(surprisingCases == 0 && isSurprisingCase) ){
				Integer maxNextVal = findMaxValue( explodedValues, index+1, ( isSurprisingCase ? (surprisingCases-1) : surprisingCases ), atLeastThisResult );
				if( maxNextVal != null ){
					maxNextVal += ( ( curCmb[ 0 ] >= atLeastThisResult || curCmb[ 1 ] >= atLeastThisResult || curCmb[ 2 ] >= atLeastThisResult ) ? 1 : 0 );
					if( retValue == null || retValue.intValue() < maxNextVal.intValue() ){
						retValue = maxNextVal;
					}
				}
			}
		}
		return retValue;
	}
	
	
	private static void solveProblem( File inputFile ) throws IOException{
		BufferedReader bufferedReader = new BufferedReader( new FileReader( inputFile ) );
		BufferedWriter bufferedWriter = new BufferedWriter( new FileWriter( new File( inputFile.getParent(), inputFile.getName().substring( 0, inputFile.getName().length()-3 )+".out" ) ) );
		Long t = Long.parseLong( bufferedReader.readLine() );
		String problem = null;
		StringBuilder solution = null;
		for( long problemIndex = 0l; problemIndex < t; problemIndex++ ){
			problem = bufferedReader.readLine();
			solution = new StringBuilder("Case #"+(problemIndex+1)+": ");			
			String[] splitProblem = problem.split(" ");
			//int n = Integer.parseInt( splitProblem[ 0 ] );
			int s = Integer.parseInt( splitProblem[ 1 ] );
			int p = Integer.parseInt( splitProblem[ 2 ] );
			int scores[] = new int[ splitProblem.length - 3 ];
			for( int i = 0; i < scores.length; i++ ){
				scores[ i ] = Integer.parseInt( splitProblem[ 3+i ] );
			}
			solution.append( findGooglerAtLeastOrBetter( s, p, scores ) );			
			bufferedWriter.write( solution.toString() );
			bufferedWriter.write( "\n" );
		}
		bufferedWriter.flush();
		bufferedWriter.close();
		bufferedReader.close();
	}
		
	private static int[][] mask = {{0,0,0},{-1,0,1},{-1,1,0},{1,-1,0},{0,-1,1},{1,0,-1},{0,1,-1}};
	
	private static boolean checkNewItem( int newItem[], int totalScore ){
		return ( newItem[0] >= 0 && newItem[0] <= 10 && newItem[1] >= 0 && newItem[1] <= 10 && newItem[2] >= 0 && newItem[2] <= 10 && (newItem[0]+newItem[1]+newItem[2]) == totalScore && ( newItem[2]-newItem[1] ) >= 0 && ( newItem[2]-newItem[1] ) <= 2 && ( newItem[1]-newItem[0] ) >= 0 && ( newItem[1]-newItem[0] ) <= 2 && ( newItem[2]-newItem[0] ) <= 2 );
	}
	private static List<int[]> findCombinations( int totalScore ){
		List<int[]> retValue = new ArrayList<int[]>();
		int divisor = (totalScore / 3);
		int iterator[] = new int[]{divisor,divisor,(totalScore-2*divisor)};
		for( int i = 0; i < mask.length; i++){
			int newItem[] = new int[]{iterator[0]+mask[i][0], iterator[1]+mask[i][1], iterator[2]+mask[i][2]};
			if( checkNewItem( newItem, totalScore ) ){
				retValue.add( newItem );
			}
		}
		return retValue;
	}
	
	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {		
		File folder = new File(".");
		System.out.println("Searching files in "+folder.getAbsolutePath());
		String[] inputFileList = folder.list( new FilenameFilter() {			
			@Override
			public boolean accept(java.io.File dir, String name) {
				return name != null && name.endsWith(".in");
			}
		});
		for( String fileName : inputFileList ){
			System.out.println( fileName );
			Main.solveProblem( new File( folder.getAbsolutePath(), fileName ) );
		}
	}

}
