void handleScanFiles(JTextField field, String[] extensions) {
String[] dataFiles = scanDataFolderForFilesByType(extensions);
if (dataFiles == null || dataFiles.length == 0) return;
String[] oldFileList = field.getText().trim().split(",");
ArrayList<String> newFileList = new ArrayList<String>();
for (String c : oldFileList) {
c = c.trim();
if (!c.equals("") && newFileList.indexOf(c) == -1) // TODO check exists() here?
{
newFileList.add(c);
}
}
for (String c : dataFiles) {
c = c.trim();
if (!c.equals("") && newFileList.indexOf(c) == -1) {
newFileList.add(c);
}
}
Collections.sort(newFileList);
String finalFileList = "";
int i = 0;
for (String s : newFileList) {
finalFileList += (i > 0 ? ", " : "") + s;
i++;
}
field.setText(finalFileList);
}
private static void getTopDocuments(int num, HashMap<String, Float> scoremap, String filename)
throws FileNotFoundException {
PrintWriter out = new PrintWriter(filename);
Iterator<String> itr = scoremap.keySet().iterator();
ArrayList<String> urls = new ArrayList<String>();
ArrayList<Float> scores = new ArrayList<Float>();
while (itr.hasNext()) {
String key = itr.next();
if (scores.size() < num) {
scores.add(scoremap.get(key));
urls.add(key);
} else {
int index = scores.indexOf(Collections.min(scores));
if (scores.get(index) < scoremap.get(key)) {
scores.set(index, scoremap.get(key));
urls.set(index, key);
}
}
}
while (scores.size() > 0) {
int index = scores.indexOf(Collections.max(scores));
out.println(urls.get(index) + "\t" + scores.get(index));
urls.remove(index);
scores.remove(index);
}
out.close();
}
public static void main(String[] args) throws IOException {
// Use BufferedReader rather than RandomAccessFile; it's much faster
BufferedReader f = new BufferedReader(new FileReader("badrand.in"));
// input file name goes above
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("badrand.out")));
// Use StringTokenizer vs. readLine/split -- lots faster
StringTokenizer st = new StringTokenizer(f.readLine());
// Get line, break into tokens
int i1 = Integer.parseInt(st.nextToken()); // first integer
ArrayList squares = new ArrayList<Integer>(10000);
int mark = 0;
i1 = middleSquare(i1);
while (i1 > 0) {
if (squares.contains(i1)) {
squares.add(i1);
squares.set(squares.indexOf(i1), 10000);
mark = i1;
i1 = 0;
} else {
squares.add(i1);
i1 = middleSquare(i1);
}
}
squares.add(10000);
squares.add(0);
out.println(squares.indexOf(mark) + 1);
out.close(); // close the output file
System.exit(0); // don't omit this!
}
private void parseDirective(String directive) {
if (directive == null) {
System.err.println("Directive is null.");
return;
}
String[] pair = directive.split("=");
if (pair == null || pair.length != 2) {
System.err.println("Unable to parse directive: \"" + directive + "\" Ignored.");
return;
}
String key = pair[0].trim(), value = pair[1].trim();
// clean these, might have too much whitespace around commas
if (validKeys.indexOf(key) == FONT || validKeys.indexOf(key) == PRELOAD) {
value = value.replaceAll("[\\s]*,[\\s]*", ",");
}
if (validKeys.indexOf(key) == -1) {
System.err.println("Directive key not recognized: \"" + key + "\" Ignored.");
return;
}
if (value.equals("")) {
System.err.println("Directive value empty. Ignored.");
return;
}
value = value.replaceAll("^\"|\"$", "").replaceAll("^'|'$", "");
// System.out.println( key + " = " + value );
boolean v;
switch (validKeys.indexOf(key)) {
case CRISP:
v = value.toLowerCase().equals("true");
crispBox.setSelected(v);
break;
case FONT:
fontField.setText(value);
break;
case GLOBAL_KEY_EVENTS:
v = value.toLowerCase().equals("true");
globalKeyEventsBox.setSelected(v);
break;
case PAUSE_ON_BLUR:
v = value.toLowerCase().equals("true");
pauseOnBlurBox.setSelected(v);
break;
case PRELOAD:
preloadField.setText(value);
break;
case TRANSPARENT:
v = value.toLowerCase().equals("true");
// transparentBox.setSelected(v);
break;
}
}
/**
* removes a user from the user list
*
* @param un the name of the user to be removed
*/
public void userDel(String un) {
users.remove(users.indexOf(un));
if (ignores.contains(un)) {
ignores.remove(ignores.indexOf(un));
}
if (afks.contains(un)) {
afks.remove(afks.indexOf(un));
}
if (admins.contains(un)) {
admins.remove(admins.indexOf(un));
}
updateList();
serverMessage(un + " has left " + server.channel);
privates.serverMessage(un, un + " has left");
}
public static void main(String[] args) throws IOException {
String line = "";
ArrayList<String> list = new ArrayList<>();
try (Scanner scanner = new Scanner(System.in);
BufferedReader reader = new BufferedReader(new FileReader(scanner.nextLine()))) {
while ((line = reader.readLine()) != null) {
list.addAll(Arrays.asList(line.split(" ")));
}
for (int i = 0; i < list.size(); i++) {
String s = list.get(i);
String reverse = new StringBuffer(s).reverse().toString();
if (list.indexOf(reverse) != -1 & !s.equals("") & !s.equals(reverse)) {
result.add(new Pair(s, reverse));
list.remove(s);
list.remove(reverse);
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
// Checks whether a person is in the ArrayList that tracks all persons to be plotted
public boolean isSelected(Person person) {
if (selected.indexOf(person) != -1) {
return true;
} else {
return false;
}
}
public static void insert_element(int temp, int temp_size) {
int numberToBeInserted = 0;
iterator++;
for (int i = 0; i < temp_size; i++) {
numberToBeInserted = temp + i;
// case 1 : (item is not in the cache)
if (!cache.contains(numberToBeInserted)) {
miss_count++;
// if cache is full : delete the lru position and paste the item
// at MRU
if (cache.size() == cache_size) {
cache.remove(cache_size - 1);
cache.add(0, numberToBeInserted);
}
// if cache is not full : paste Item at MRU
else {
cache.add(0, numberToBeInserted);
}
}
// case 2 : item is in the cache bring item to the beginning)
else {
hit_count++;
cache.remove(cache.indexOf(numberToBeInserted));
cache.add(1, numberToBeInserted);
}
}
}
public final int removeFromNetwork(final ABPortal portal) {
final ArrayList<UUID> portals = getNetwork(portal.network, portal.color, portal.owner);
final int index = portals.indexOf(portal.uid);
if (index != -1) portals.remove(index);
return index;
}
public void drawCluster(Cluster cluster) {
int index = clusters.indexOf(cluster);
if (index != -1) {
cluster.y = maxY;
cluster.x = minX + index * factor;
if (cluster.size() > 1) g.setColor(Color.RED);
else g.setColor(Color.BLACK);
g.drawRect(cluster.x - 1, cluster.y - cluster.size(), 2, 1 + cluster.size());
} else {
Cluster left = cluster.getLeft();
Cluster right = cluster.getRight();
drawCluster(left);
drawCluster(right);
int yBar = minY + (int) ((maxY - minY) * (cluster.getSimilarity() / threshold));
g.setColor(Color.DARK_GRAY);
if (left.y > yBar) {
g.drawLine(left.x, left.y - 1, left.x, yBar);
writeMap(left, yBar);
}
if (right.y > yBar) {
g.drawLine(right.x, right.y - 1, right.x, yBar);
writeMap(right, yBar);
}
g.setColor(Color.BLACK);
g.drawLine(left.x, yBar, right.x, yBar);
cluster.x = (right.x + left.x) / 2;
cluster.y = yBar;
}
}
public static void main(String[] args) {
ArrayList<String> a = new ArrayList<String>();
a.add(0, "zero");
a.add(1, "one");
a.add(2, "two");
a.add(3, "three");
printAL(a);
a.remove(2);
if (a.contains("three")) {
a.add("four");
}
printAL(a);
if (a.indexOf("four") != 4) {
a.add(4, "4,2");
}
printAL(a);
printAL(a);
}
@Override
public void databaseChanged(DatabaseChangeEvent e) {
synchronized (set) {
int pos;
switch (e.getType()) {
case ADDED_ENTRY:
pos = -Collections.binarySearch(set, e.getEntry(), comp) - 1;
set.add(pos, e.getEntry());
// addEntry(e.getEntry());
// set.add(e.getEntry());
// changed = true;
// Collections.sort(set, comp);
break;
case REMOVED_ENTRY:
set.remove(e.getEntry());
changed = true;
break;
case CHANGED_ENTRY:
// Entry changed. Resort list:
// Collections.sort(set, comp);
pos = Collections.binarySearch(set, e.getEntry(), comp);
int posOld = set.indexOf(e.getEntry());
if (pos < 0) {
set.remove(posOld);
set.add(-pos - 1, e.getEntry());
}
// changed = true;
break;
}
}
}
public void removeOwnership(String group) {
if (!ownership.isEmpty()) {
if (ownership.contains(group)) {
ownership.remove(ownership.indexOf(group));
}
}
}
/** @param entity */
public void free(GameObject entity) {
free.add(entity);
entity.freeIndex = free.indexOf(entity); // or size
if (entity.getClient() != null) {
clients.remove(entity);
}
}
private void setProposeReceived(Address address) {
int idx = destinations.indexOf(address);
if (idx == -1) {
throw new IllegalStateException(
"Address doesn't exists in destination list. Address is " + address);
}
receivedPropose.set(idx, false);
}
public void toggleFavorite(int index) {
Board t = getItem(index);
t.favorite = !t.favorite;
mDataShown.set(index, t);
mAllData.set(mAllData.indexOf(t), t);
Log.i("debug", "State : " + t.favorite);
super.notifyDataSetChanged();
}
public void removeGroup(String group) {
if (!groups.isEmpty()) {
if (groups.contains(group)) {
// TODO also remove them from the group_list group
groups.remove(groups.indexOf(group));
}
}
}
/**
* changes the name of a user, updating list of admins, afks, ignoes, and master user list
*
* @param on old username
* @param nn new username
*/
public void rename(String on, String nn) {
if (admins.contains(on)) {
admins.remove(admins.indexOf(on));
admins.add(nn);
}
if (afks.contains(on)) {
afks.remove(afks.indexOf(on));
afks.add(nn);
}
if (ignores.contains(on)) {
ignores.remove(ignores.indexOf(on));
ignores.add(nn);
}
users.remove(on);
users.add(nn);
updateList();
serverMessage(on + " renamed to " + nn);
}
public void clearConnectedNodes() {
for (int k = connectedNodes.size() - 1; k >= 0; k--) {
ArrayList<KNode> otherConnectedNodes = connectedNodes.get(k).getConnectedNodes();
int index = otherConnectedNodes.indexOf(this);
assert index != -1;
otherConnectedNodes.remove(index);
}
connectedNodes.clear();
}
public void removeMessageListener(MessageListener listener) {
synchronized (listeners) {
int idx = listeners.indexOf(listener);
if (idx >= 0) {
listenersDownload.remove(idx);
listeners.remove(listener);
}
}
}
public synchronized boolean removeLeavers(Collection<Address> leavers) {
for (Address address : leavers) {
int idx = destinations.indexOf(address);
if (idx == -1) {
continue;
}
receivedPropose.set(idx, false);
}
return checkAllProposesReceived();
}
public GameObject obtain() { // TODO lock, on optimize
GameObject entity = free.isEmpty() ? null : free.remove(0);
if (entity == null) entity = new GameObject(this);
entity.lastUsed = System.currentTimeMillis();
entitys.add(entity);
entity.index = entitys.indexOf(entity);
return entity;
}
public void consolidateItems() {
ArrayList<OrderItem> newOrderList = new ArrayList<OrderItem>();
for (OrderItem i : items) {
if (newOrderList.contains(i)) {
updateOrderItem(newOrderList.indexOf(i), i.getQuantity());
} else {
newOrderList.add(i);
}
}
items = newOrderList;
}
// Mutators
public void vote(String candidate) {
// update the array of votes to reflect the user selection
int index = _candidates.indexOf(candidate);
if (index != -1) {
_votes[index]++;
System.out.println("Voted for: " + _candidates.get(index));
System.out.println("Current votes: " + _votes[index]);
} else {
System.out.println("No vote");
}
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
final String[] code = {
".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--",
"-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--..",
"..--", ".-.-", "---.", "----"
};
final String[] letters = {
"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", "_", ",", ".", "?"
};
while (in.hasNext()) {
char[] a = in.nextLine().toCharArray();
ArrayList<Integer> nums = new ArrayList<>();
String result = "";
for (char x : a) {
switch (x) {
case '_':
nums.add(4);
result = result + code[26];
break;
case ',':
nums.add(4);
result = result + code[27];
break;
case '.':
nums.add(4);
result = result + code[28];
break;
case '?':
nums.add(4);
result = result + code[29];
break;
default:
String s = code[x - 'A'];
int l = s.length();
result = result + s;
nums.add(l);
break;
}
}
int index = 0;
Collections.reverse(nums);
ArrayList<String> codes = new ArrayList<>(Arrays.asList(code));
String note = "";
for (int i : nums) {
String s = result.substring(index, index + i);
note = note + letters[codes.indexOf(s)];
index += i;
}
System.out.println(note);
}
}
private ProgressIndicatorEx removeFromMaps(@NotNull InlineProgressIndicator progress) {
final ProgressIndicatorEx original = myInline2Original.get(progress);
myInline2Original.remove(progress);
myOriginal2Inlines.remove(original, progress);
if (myOriginal2Inlines.get(original) == null) {
final int originalIndex = myOriginals.indexOf(original);
myOriginals.remove(originalIndex);
myInfos.remove(originalIndex);
}
return original;
}
@Test
public void testIndexOfNull() throws Exception {
// Im testing
System.out.println("Testing indexOf NULL");
// Given
list.add(1);
list.add(null);
list.add(3);
list.add(4);
// When
int got = list.indexOf(1, null);
// Then
Assert.assertEquals(1, got);
System.out.println("looking for nr NULL, found at " + got);
}
@Test
public void testIndexOfSimple() throws Exception {
// Im testing
System.out.println("Simple index of");
// Given
list.add(1);
list.add(2);
list.add(3);
list.add(4);
// When
int got = list.indexOf(3);
// Then
Assert.assertEquals(2, got);
System.out.println("looking for nr 3, found at " + got);
}
@Test
public void testIndexOfNotFound() throws Exception {
// Im testing
System.out.println("Testing indexOf not finding");
// Given
list.add(1);
list.add(2);
list.add(3);
list.add(4);
// When
int got = list.indexOf(1, 5);
// Then
Assert.assertEquals(-1, got);
System.out.println("looking for nr 5, didnt find it got: " + got);
}
private Segment createSegmentFromEdges(long edgeId, long segmentId, boolean isEdgeOrigin) {
double length = 0.0;
Segment seg = null;
try {
List<Edge> subset = null;
seg = db.ReadSegment(segmentId);
ArrayList<Edge> edges = db.ReadEdges(segmentId);
Edge edge = null;
if (!edges.isEmpty()) {
if (isEdgeOrigin) {
edge =
edges
.stream()
.filter(
(Edge e) -> {
return e.mOrigin == edgeId;
})
.findFirst()
.get();
} else {
edge =
edges
.stream()
.filter(
(Edge e) -> {
return e.mDestination == edgeId;
})
.findFirst()
.get();
}
int index = edges.indexOf(edge);
subset = edges.subList(index, edges.size());
for (Edge ed : subset) {
length = +ed.mLength;
}
}
long origin, destination;
origin = (isEdgeOrigin ? edgeId : seg.mOrigin);
destination = (isEdgeOrigin ? seg.mDestination : edgeId);
Segment s = new Segment(nextSegId++, length, seg.mWayId, origin, destination);
return s;
} catch (SQLException e) {
System.err.println("Error getting segmentid from method modelNodeToSegment");
e.printStackTrace();
}
return null;
}
