public static void recSort(ArrayList<Integer> arr, int left, int right) { if (left >= right) return; int mid = (left + right) / 2; recSort(arr, left, mid); recSort(arr, mid + 1, right); // combine ArrayList<Integer> copy = new ArrayList<Integer>(); // MERGE int a = left; int b = mid + 1; while (a <= mid && b <= right) { int cmp; cmp = arr.get(a) - arr.get(b); if (cmp < 0) copy.add(arr.get(a++)); else copy.add(arr.get(b++)); } while (a <= mid) copy.add(arr.get(a++)); while (b <= right) copy.add(arr.get(b++)); // Put back int c = 0; for (int i = left; i <= right; i++) arr.set(i, copy.get(c++)); }
private MockTelemetryModule generateTelemetryModules(boolean addParameter) { AppInsightsConfigurationBuilder mockParser = createMockParser(true, true, false); ApplicationInsightsXmlConfiguration appConf = mockParser.build(null); appConf.setInstrumentationKey(MOCK_IKEY); TelemetryModulesXmlElement modulesXmlElement = new TelemetryModulesXmlElement(); ArrayList<AddTypeXmlElement> modules = new ArrayList<AddTypeXmlElement>(); AddTypeXmlElement addXmlElement = new AddTypeXmlElement(); addXmlElement.setType("com.microsoft.applicationinsights.internal.config.MockTelemetryModule"); if (addParameter) { final ParamXmlElement param1 = new ParamXmlElement(); param1.setName("param1"); param1.setValue("value1"); ArrayList<ParamXmlElement> list = new ArrayList<ParamXmlElement>(); list.add(param1); addXmlElement.setParameters(list); } modules.add(addXmlElement); modulesXmlElement.setAdds(modules); appConf.setModules(modulesXmlElement); TelemetryConfiguration mockConfiguration = new TelemetryConfiguration(); initializeWithFactory(mockParser, mockConfiguration); MockTelemetryModule module = (MockTelemetryModule) mockConfiguration.getTelemetryModules().get(0); return module; }
public void init() { Scanner scan = new Scanner(System.in); count = scan.nextInt(); x0 = scan.nextLong(); y0 = scan.nextLong(); int result = 0; boolean special = false; for (int i = 0; i < count; i++) { long tempx = scan.nextLong(); long tempy = scan.nextLong(); if (tempx == x0 && tempy == y0) { special = true; continue; } boolean isDuplicate = false; for (int j = 0; j < result; j++) { long x1 = xList.get(j); long y1 = yList.get(j); if ((x1 - x0) * (tempy - y0) == (y1 - y0) * (tempx - x0)) { isDuplicate = true; break; } } if (!isDuplicate) { xList.add(tempx); yList.add(tempy); result++; } } if (special && result == 0) result = 1; System.out.println(result); scan.close(); }
@SuppressWarnings("unchecked") @Override public List<Version> getVersions() { if (versions == null) { int count = 1; if (revisions != null) { count = count + revisions.size(); } ArrayList<Version> list = new ArrayList<>(count); if (getTime() != Long.MIN_VALUE) { list.add(new Version(this)); } if (revisions != null) { for (LongRevision lr : revisions) { if (lr.getTime() != Long.MIN_VALUE) { list.add(new Version(lr)); } } } versions = list; } return (List<Version>) versions; }
public MoquiStart(ClassLoader parent, boolean loadWebInf) { super(parent); this.loadWebInf = loadWebInf; URL wrapperWarUrl = null; try { // get outer file (the war file) pd = getClass().getProtectionDomain(); CodeSource cs = pd.getCodeSource(); wrapperWarUrl = cs.getLocation(); outerFile = new JarFile(new File(wrapperWarUrl.toURI())); // allow for classes in the outerFile as well jarFileList.add(outerFile); Enumeration<JarEntry> jarEntries = outerFile.entries(); while (jarEntries.hasMoreElements()) { JarEntry je = jarEntries.nextElement(); if (je.isDirectory()) continue; // if we aren't loading the WEB-INF files and it is one, skip it if (!loadWebInf && je.getName().startsWith("WEB-INF")) continue; // get jars, can be anywhere in the file String jeName = je.getName().toLowerCase(); if (jeName.lastIndexOf(".jar") == jeName.length() - 4) { File file = createTempFile(je); jarFileList.add(new JarFile(file)); } } } catch (Exception e) { System.out.println("Error loading jars in war file [" + wrapperWarUrl + "]: " + e.toString()); } }
public void addProgress(@NotNull ProgressIndicatorEx original, @NotNull TaskInfo info) { synchronized (myOriginals) { final boolean veryFirst = !hasProgressIndicators(); myOriginals.add(original); myInfos.add(info); final InlineProgressIndicator expanded = createInlineDelegate(info, original, false); final InlineProgressIndicator compact = createInlineDelegate(info, original, true); myPopup.addIndicator(expanded); myProgressIcon.resume(); if (veryFirst && !myPopup.isShowing()) { buildInInlineIndicator(compact); } else { buildInProcessCount(); if (myInfos.size() > 1 && Registry.is("ide.windowSystem.autoShowProcessPopup")) { openProcessPopup(false); } } runQuery(); } }
private Collection<Modifier> generateModifiers(int modifiers) { ArrayList<Modifier> mods = new ArrayList<Modifier>(); // first, protection modifiers switch (modifiers & WyilFileWriter.MODIFIER_PROTECTION_MASK) { case WyilFileWriter.MODIFIER_Public: mods.add(Modifier.PUBLIC); break; case WyilFileWriter.MODIFIER_Protected: mods.add(Modifier.PROTECTED); break; case WyilFileWriter.MODIFIER_Private: mods.add(Modifier.PRIVATE); break; default: throw new RuntimeException("Unknown modifier"); } // second, mangle modifiers switch (modifiers & WyilFileWriter.MODIFIER_MANGLE_MASK) { case WyilFileWriter.MODIFIER_Native: mods.add(Modifier.NATIVE); break; case WyilFileWriter.MODIFIER_Export: mods.add(Modifier.EXPORT); break; } return mods; }
public static List<AttrPack> expand(AttrPack attr) { char node_type_list[] = new char[4]; List<Integer> rimo_path = getRightMostPath(attr.getPath()); // List<Integer> rimo_path = getRightMostPath(debug); // List<Tuple> cand = rightMostExpand(debug); List<Tuple> cand = rightMostExpand(attr.getPath()); char[] path_label = new char[rimo_path.size() + 1]; int[] path_index = new int[rimo_path.size()]; for (int i = 0; i < rimo_path.size(); i++) { path_index[i] = rimo_path.get(i); path_label[i] = attr.getPath().get(path_index[i]).getLabel(); } path_label[rimo_path.size()] = 0; List<AttrPack> next_iter = new ArrayList(); if (attr.getPathIndex() == -1) { for (Tuple tup : cand) { int d_ = tup.getDepth(); char l_ = tup.getLabel(); if (l_ == path_label[d_]) { ArrayList<Tuple> tmp_path = new ArrayList(attr.getPath()); tmp_path.add(new Tuple(d_, l_)); next_iter.add(new AttrPack(tmp_path, path_index[d_])); } if (l_ > path_label[d_]) { ArrayList<Tuple> tmp_path = new ArrayList(attr.getPath()); tmp_path.add(new Tuple(d_, l_)); next_iter.add(new AttrPack(tmp_path, -1)); } } } else { int prefix = attr.getPathIndex() + 1; Tuple prf_tup = attr.getPath().get(prefix); { ArrayList<Tuple> tmp_path = new ArrayList(attr.getPath()); tmp_path.add(prf_tup); next_iter.add(new AttrPack(tmp_path, prefix)); } for (Tuple tup : cand) { int d_ = tup.getDepth(); char l_ = tup.getLabel(); if (d_ > prf_tup.getDepth()) { continue; } if (d_ == prf_tup.getDepth() && l_ >= prf_tup.getLabel()) { continue; } if (l_ == path_label[d_]) { ArrayList<Tuple> tmp_path = new ArrayList(attr.getPath()); tmp_path.add(new Tuple(d_, l_)); next_iter.add(new AttrPack(tmp_path, path_index[d_])); } if (l_ > path_label[d_]) { ArrayList<Tuple> tmp_path = new ArrayList(attr.getPath()); tmp_path.add(new Tuple(d_, l_)); next_iter.add(new AttrPack(tmp_path, -1)); } } } return next_iter; }
public void updateNodeName(String oldName, String newName) { // Update in the whole Tree if (!oldName.isEmpty() && !newName.isEmpty()) { Enumeration en = root.depthFirstEnumeration(); while (en.hasMoreElements()) { DecisionTreeNode node = (DecisionTreeNode) en.nextElement(); if (node.nodeName.compareTo(oldName) == 0) { node.nodeName = newName; } } } // Update in the added Node List ArrayList<String> nodesToBeAdded = new ArrayList<String>(addedNodes); addedNodes.clear(); for (String node : nodesToBeAdded) { String[] arr = node.split(":"); if (arr[1].compareTo(oldName) == 0) { addedNodes.add(arr[0] + ":" + newName + ":" + arr[2]); } else { addedNodes.add(node); } } // Update in the correctNode list correctNodes.put(newName, correctNodes.get(oldName)); correctNodes.remove(oldName); }
public ArrayList<String> letterCombinations(String digits) { // Start typing your Java solution below // DO NOT write main() function /* brillant idea to store those values into string */ String[] arrays = new String[10]; arrays[2] = "abc"; arrays[3] = "def"; arrays[4] = "ghi"; arrays[5] = "jkl"; arrays[6] = "mno"; arrays[7] = "pqrs"; arrays[8] = "tuv"; arrays[9] = "wxyz"; ArrayList<String> result = new ArrayList<String>(); result.add(""); if (digits.length() == 0) return result; for (int i = 0; i < digits.length(); i++) { String num = arrays[digits.charAt(i) - '0']; ArrayList<String> tempResult = new ArrayList<String>(); for (String s : result) { for (int j = 0; j < num.length(); j++) { tempResult.add(s + num.charAt(j)); } } result = tempResult; } return result; }
// TODO Check https://leetcode.com/discuss/58149/my-simple-java-solution public int[] plusOne(int[] digits) { if (digits == null || digits.length == 0) return digits; ArrayList<Integer> list = new ArrayList<Integer>(); int elementToAdd = 1; for (int i = digits.length - 1; i >= 0; i--) { int newElem = digits[i] + elementToAdd; elementToAdd = 0; if (newElem > 9) { elementToAdd = 1; newElem = 0; } list.add(newElem); } if (elementToAdd == 1) { list.add(elementToAdd); } int[] result = new int[list.size()]; for (int i = 0; i < list.size(); i++) { result[list.size() - i - 1] = list.get(i); } return result; }
/** * Return true if all predicate tests on a certain resource entry evaluate to true * * @param resource the resource * @param allowListMatch if true, allow the test to be a list of strings * @param predicateTransformer a Converter<S,Predicate> to convert String to Predicate test * @param key the resource attribute key to check * @param test test to apply, can be a String, or List of Strings if allowListMatch is true */ boolean applyTest( final Map<String, String> resource, final boolean allowListMatch, final Converter<String, Predicate> predicateTransformer, final String key, final Object test) { final ArrayList<Predicate> tests = new ArrayList<Predicate>(); if (allowListMatch && test instanceof List) { // must match all values for (final Object item : (List) test) { final String s = (String) item; tests.add(predicateTransformer.convert(s)); } } else if (test instanceof String) { // match single test tests.add(predicateTransformer.convert((String) test)); } else { // unexpected format, do not match logger.error( identify() + ": cannot evaluate unexpected type: " + test.getClass().getName()); return false; } return PredicateUtils.allPredicate(tests).evaluate(resource.get(key)); }
public boolean comparePrefix(String prefixCode, String prefixCodeWithProc) { try { boolean flag = false; String prefixBreak[] = prefixCode.split("#"); String prefixProcBreak[] = prefixCodeWithProc.split("#"); for (String str : prefixBreak) { flag = false; for (int i = 0; i < prefixProcBreak.length; i++) { if (prefixProcBreak[i].equals(str)) { flag = true; prefixProcBreak[i] = "-1"; break; } } if (!flag) return false; } if (prefixCode.length() == prefixCodeWithProc.length()) { procList.clear(); procList.add(prefixCodeWithProc); return true; } else procList.add(prefixCodeWithProc); } catch (Exception ed) { } return false; }
public static void main(String[] args) { FileSystemNode d1, d2, d3, d4; ArrayList<FileSystemNode> l1, l2; d1 = new FileNode("opg87", 120); assert d1.accept(new SizeVisitor()) == 120; d2 = new FileNode("opg14", 125); l1 = new ArrayList<FileSystemNode>(); l1.add(d1); l1.add(d2); d3 = new DirectoryNode("obl", l1); assert d3.accept(new SizeVisitor()) == 245; d4 = new DirectoryNode("B-opgaver", new ArrayList<FileSystemNode>()); assert d4.accept(new SizeVisitor()) == 0; l2 = new ArrayList<FileSystemNode>(); l2.add(d3); l2.add(d4); d3 = new DirectoryNode("dprog2", l2); // d3.accept(new ListFileSizeVisitor()); // d3.accept(new SearchVisitor("opg")); try { assert false; System.out.println("Please enable assertions!"); } catch (AssertionError e) { System.out.println("Success!"); } }
private void handleNewExternalTransactionsInt(Collection<TransactionEx> transactions) throws WapiException { // Transform and put into two arrays with matching indexes ArrayList<TransactionEx> texArray = new ArrayList<TransactionEx>(transactions.size()); ArrayList<Transaction> txArray = new ArrayList<Transaction>(transactions.size()); for (TransactionEx tex : transactions) { try { txArray.add(Transaction.fromByteReader(new ByteReader(tex.binary))); texArray.add(tex); } catch (TransactionParsingException e) { // We hit a transaction that we cannot parse. Log but otherwise ignore it _logger.logError("Received transaction that we cannot parse: " + tex.txid.toString()); continue; } } // Grab and handle parent transactions fetchStoreAndValidateParentOutputs(txArray); // Store transaction locally for (int i = 0; i < txArray.size(); i++) { _backing.putTransaction(texArray.get(i)); onNewTransaction(texArray.get(i), txArray.get(i)); } }
public WDBObject[] search(SimpleNode expression, Adapter scda) throws Exception { boolean hasWhereClause = (expression != null); WDBObject[] matchesArray = new WDBObject[0]; ArrayList<WDBObject> matchesList = new ArrayList<WDBObject>(); WDBObject[] indexFilteredArray; if (hasWhereClause) { indexFilteredArray = expression .filterObjectsWithIndexes(scda, this.indexes) .getFilteredResults(scda, this.indexes); } else { indexFilteredArray = null; } if (indexFilteredArray == null) { // Simple for loop for search WDBObject object; for (int i = 0; i < this.instances.size(); i++) { object = this.getInstance(i, scda); if (!hasWhereClause || (hasWhereClause && expression.eval(scda, object))) { matchesList.add(object); } } } else { // Simple for loop for search for (int i = 0; i < indexFilteredArray.length; i++) { if (!hasWhereClause || (hasWhereClause && expression.eval(scda, indexFilteredArray[i]))) { matchesList.add(indexFilteredArray[i]); } } } return (WDBObject[]) matchesList.toArray(matchesArray); }
public Cube(double x, double y, double z, double w) { super(); id = "Cube"; width = w; ArrayList<Point3D> pts = new ArrayList<Point3D>(); pts.add(new Point3D(x, y, z)); pts.add(new Point3D(x + w, y, z)); pts.add(new Point3D(x + w, y + w, z)); pts.add(new Point3D(x, y + w, z)); for (int i = 0; i < pts.size() - 1; i++) { lines.add(new Line3D(pts.get(i), pts.get(i + 1))); } lines.add(new Line3D(pts.get(0), new Point3D(x, y + w, z))); int size = lines.size(); for (int i = 0; i < size; i++) { lines.add( new Line3D( new Point3D(lines.get(i).point1.x, lines.get(i).point1.y, lines.get(i).point1.z + w), new Point3D( lines.get(i).point2.x, lines.get(i).point2.y, lines.get(i).point2.z + w))); } size = pts.size(); for (int i = 0; i < size; i++) { pts.add(new Point3D(pts.get(i).x, pts.get(i).y, pts.get(i).z + w)); } for (int i = 0; i < 4; i++) { lines.add(new Line3D(pts.get(i), pts.get(i + 4))); } pan(new Point3D(0, 0, 0)); }
/** Gets all permutations of a given word. */ public ArrayList<String> getPermutations() { ArrayList<String> result = new ArrayList<String>(); // The empty string has a single permutation: itself if (word.length() == 0) { result.add(word); return result; } // Loop through all character positions for (int i = 0; i < word.length(); i++) { // Form a simpler word by removing the ith character String shorterWord = word.substring(0, i) + word.substring(i + 1); // Generate all permutations of the simpler word Permutations shorterPermutations = new Permutations(shorterWord); ArrayList<String> shorterWordPermutations = shorterPermutations.getPermutations(); // Add the removed character to the front of // each permutation of the simpler word, for (String s : shorterWordPermutations) { result.add(word.charAt(i) + s); } } // Return all permutations return result; }
private void marceros(int[] cerodesparej, int[] filnosel) { int i, j = cerodesparej[1]; ArrayList<int[]> secero = new ArrayList<int[]>(); secero.add(cerodesparej); boolean apareao = false; do { i = colselec[j]; apareao = -1 != i && secero.add(new int[] {i, j}); if (!apareao) { break; } j = filnosel[i]; apareao = -1 != j && secero.add(new int[] {i, j}); } while (apareao); for (int[] zero : secero) { if (colselec[zero[1]] == zero[0]) { colselec[zero[1]] = -1; filselec[zero[0]] = -1; } if (filnosel[zero[0]] == zero[1]) { filselec[zero[0]] = zero[1]; colselec[zero[1]] = zero[0]; } } }
public static void findMaxCut() { int arrayCut = Integer.MAX_VALUE; int indexCut = Integer.MAX_VALUE; int max = Integer.MIN_VALUE; int numArrays = occupied.size(); for (int i = 0; i < numArrays; i++) { ArrayList<Integer> arr = occupied.get(i); int len = arr.size(); for (int j = 0; j < len - 1; j++) { if (arr.get(j + 1) - arr.get(j) > max) { max = arr.get(j + 1) - arr.get(j); indexCut = j; arrayCut = i; } } } ArrayList<Integer> arr1 = new ArrayList<Integer>(); ArrayList<Integer> arr2 = new ArrayList<Integer>(); ArrayList<Integer> arr = occupied.get(arrayCut); for (int i = 0; i <= indexCut; i++) { arr1.add(arr.get(i)); } for (int i = indexCut + 1; i < arr.size(); i++) { arr2.add(arr.get(i)); } occupied.remove(arrayCut); occupied.add(arr1); occupied.add(arr2); }
public static void main(String[] args) throws FileNotFoundException { String s; ArrayList<String> AL = new ArrayList<String>(); AL.add("one"); AL.add("two"); AL.add("three"); AL.add("four"); AL.add("five"); AL.add("six"); System.out.println("ArrayList (iterator) " + AL); Iterator<String> it = AL.iterator(); while (it.hasNext()) { s = it.next(); System.out.println("AL: " + s); } System.out.println(); myList ml = new myList(); ml.add(20); ml.add(50); ml.add(12); ml.add(13); ml.add(53); ml.add(33); ml.add(23); System.out.println(ml); Iterator<Integer> mlit = ml.iterator(); while (mlit.hasNext()) { System.out.println(mlit.next()); } }
private static CommandLineArgumentsProvider createCommandLineArgumentsProvider( final Sdk sdk, final Map<String, String> environmentVariables, int[] ports) { final ArrayList<String> args = new ArrayList<String>(); args.add(sdk.getHomePath()); final String versionString = sdk.getVersionString(); if (versionString == null || !versionString.toLowerCase().contains("jython")) { args.add("-u"); } args.add( FileUtil.toSystemDependentName(PythonHelpersLocator.getHelperPath(PYDEV_PYDEVCONSOLE_PY))); for (int port : ports) { args.add(String.valueOf(port)); } return new CommandLineArgumentsProvider() { @Override public String[] getArguments() { return ArrayUtil.toStringArray(args); } @Override public boolean passParentEnvs() { return false; } @Override public Map<String, String> getAdditionalEnvs() { return addDefaultEnvironments(sdk, environmentVariables); } }; }
public ArrayList<Interval> merge(ArrayList<Interval> intervals) { // Start typing your Java solution below // DO NOT write main() function ArrayList<Interval> res = new ArrayList<Interval>(); if (intervals.size() == 0) return res; Collections.sort(intervals, new MyC()); int start = 0; int end = 0; for (int i = 0; i < intervals.size(); i++) { if (i == 0) { start = intervals.get(i).start; end = intervals.get(i).end; } else { if (intervals.get(i).start <= end) { end = Math.max(end, intervals.get(i).end); } else { res.add(new Interval(start, end)); start = intervals.get(i).start; end = intervals.get(i).end; } } } res.add(new Interval(start, end)); return res; }
public void dfs(int v) { if (hasCycle) { return; } if (color[v] != 2) { color[v] = 1; if (graph[v] == null) { color[v] = 2; answer.add(v); return; } for (int i = 0; i < graph[v].size(); i++) { int to = graph[v].get(i); if (color[to] == 0) { dfs(to); } if (color[to] == 1) { hasCycle = true; return; } } color[v] = 2; answer.add(v); } }
@Override public Object findElement(String s) { List<ObjectWithWeight> elements = new ArrayList<ObjectWithWeight>(); s = s.trim(); final ListIterator<Object> it = getElementIterator(0); while (it.hasNext()) { final ObjectWithWeight o = new ObjectWithWeight(it.next(), s, getComparator()); if (!o.weights.isEmpty()) { elements.add(o); } } ObjectWithWeight cur = null; ArrayList<ObjectWithWeight> current = new ArrayList<ObjectWithWeight>(); for (ObjectWithWeight element : elements) { if (cur == null) { cur = element; current.add(cur); continue; } final int i = element.compareWith(cur); if (i == 0) { current.add(element); } else if (i < 0) { cur = element; current.clear(); current.add(cur); } } return current.isEmpty() ? null : findClosestTo(myInitialPsiElement, current); }
/** * Given a tissue sample, move all unsatisfied agents to a vacant cell * * @param tissue a 2-D character array that has been initialized * @param threshold the percentage of like agents that must surround the agent to be satisfied */ public static int moveAllUnsatisfied(char[][] tissue, int threshold) { ArrayList<Integer> list2 = new ArrayList<Integer>(); int counter = 0; ArrayList<Integer> list1 = new ArrayList<Integer>(); for (int i = 0; i < tissue.length; i++) { for (int x = 0; x < tissue[0].length; x++) { if (isSatisfied(tissue, i, x, threshold) == false) { list1.add(i); list2.add(x); } } } int num = list1.size(); char temp; int count = 0; do { int rand = (int) (Math.random() * tissue.length); int random = (int) (Math.random() * tissue.length); if (tissue[rand][random] == ' ') { temp = tissue[rand][random]; tissue[rand][random] = tissue[list1.get(counter)][list2.get(counter)]; tissue[list1.get(counter)][list2.get(counter)] = temp; counter++; count++; } } while (counter != num); return count; }
ArrayList<String> findChunks(String code) throws CompilationException { ArrayList<String> chunks = new ArrayList<String>(); int start = 1; while (code.charAt(start) == ' ') start++; int end = start; while (end < code.length() - 1 && code.charAt(end) != ')') { if (code.charAt(start) == '(') { end = findClose(code, start); chunks.add(code.substring(start, end)); } else { while (code.charAt(end) != ' ' && code.charAt(end) != ')' && code.charAt(end) != '(') { end++; } if (start != end) { String chunk = code.substring(start, end); chunk = chunk.trim(); if (!chunk.isEmpty()) chunks.add(chunk); } } while (end < code.length() && code.charAt(end) == ' ') end++; start = end; } if (end != code.length() - 1) throw new CompilationException(code); if (code.charAt(0) == '(' && code.charAt(end) != ')') throw new CompilationException(code); return chunks; }
void $$SINGLETONS() { pkgP.init( "ti.platforms.evm6424.Package", (Proto.Obj) om.findStrict("xdc.IPackage.Module", "ti.platforms.evm6424")); pkgP.bind("$capsule", $$UNDEF); pkgV.init2(pkgP, "ti.platforms.evm6424", Value.DEFAULT, false); pkgV.bind("$name", "ti.platforms.evm6424"); pkgV.bind("$category", "Package"); pkgV.bind("$$qn", "ti.platforms.evm6424."); pkgV.bind("$vers", Global.newArray("1, 0, 0, 0")); Value.Map atmap = (Value.Map) pkgV.getv("$attr"); atmap.seal("length"); imports.clear(); imports.add(Global.newArray("ti.catalog.c6000", Global.newArray())); imports.add(Global.newArray("xdc.platform", Global.newArray(1, 0, 1))); pkgV.bind("$imports", imports); StringBuilder sb = new StringBuilder(); sb.append("var pkg = xdc.om['ti.platforms.evm6424'];\n"); sb.append("if (pkg.$vers.length >= 3) {\n"); sb.append("pkg.$vers.push(Packages.xdc.services.global.Vers.getDate(xdc.csd() + '/..'));\n"); sb.append("}\n"); sb.append("pkg.build.libraries = [\n"); sb.append("];\n"); sb.append("pkg.build.libDesc = [\n"); sb.append("];\n"); sb.append("if('suffix' in xdc.om['xdc.IPackage$$LibDesc']) {\n"); sb.append("}\n"); Global.eval(sb.toString()); }
public void createBuildings() { bList = new ArrayList<Building>(); // resource bList.add(new Building("Gold Mine", 3, 3, 960, 7)); bList.add(new Building("Elixir Collector", 3, 3, 960, 7)); // bList.add(new Building("Dark Elixir Drill", 3, 3, 1160, 3)); bList.add(new Building("Gold Storage", 3, 3, 2100, 4)); bList.add(new Building("Elixir Storage", 3, 3, 2100, 4)); // bList.add(new Building("Dark Elixir Storage", 3, 3, 3200, 1)); // bList.add(new Building("Builder Hut", 2, 2, 250, 5)); // army bList.add(new Building("Army Camp", 5, 5, 500, 4)); bList.add(new Building("Barracks", 3, 3, 860, 4)); // bList.add(new Building("Dark Barracks", 3, 3, 900, 2)); // bList.add(new Building("Laboratory", 4, 4, 950, 1)); // bList.add(new Building("Spell Factory", 3, 3, 615, 1)); // bList.add(new Building("Barbarian King Altar", 3, 3, 250, 1)); // bList.add(new Building("Dark Spell Factory", 3, 3, 750, 1)); // bList.add(new Building("Archer Queen Altar", 3, 3, 250, 1)); // other bList.add(new Building("Town Hall", 4, 4, 5500, 1)); bList.add(new Building("Clan Castle", 3, 3, 3400, 1)); // defense bList.add(new Building("Archer Tower", 3, 3, 1050, 7)); bList.add(new Building("Cannon", 3, 3, 1260, 6)); bList.add(new Building("Wall", 1, 1, 7000, 275)); // bList.add(new Building("Air Sweeper", 2, 2, 1000, 2)); // bList.add(new Building("Cannon", 3, 3, 1260, 6)); // bList.add(new Building("Cannon", 3, 3, 1260, 6)); }
public static void main(String[] args) { ArrayList<Pattern> patterns = new ArrayList<Pattern>(); ArrayList<Cut> cuts; ArrayList<Garment> garments; patterns.add(new Pattern(2, 2, 1, "Tie")); patterns.add(new Pattern(2, 6, 4, "Skirt")); patterns.add(new Pattern(4, 2, 3, "Blouse")); patterns.add(new Pattern(5, 3, 5, "Dress")); int width = 30; int height = 15; ClothCutter cutter = new ClothCutter(width, height, patterns); System.out.println("Optimized value: " + cutter.optimize()); cuts = cutter.getCuts(); garments = cutter.getGarments(); ClothPanel panel = new ClothPanel(width, height); JFrame frame = new JFrame("A luxurious bolt of fabric"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.getContentPane().add(panel); frame.pack(); frame.setVisible(true); sleep(1000); for (int i = 0; i < cuts.size(); i++) { panel.drawCut(cuts.get(i)); sleep(100); } for (int i = 0; i < garments.size(); i++) { System.out.println(garments.get(i)); panel.drawGarment(garments.get(i)); sleep(100); } }