/**
* Convert a BAM file containing paried-end tags to the ascii "pair" format used for HiC.
*
* @param inputBam
* @param outputFile
* @throws IOException
*/
public static void filterBam(String inputBam, String outputFile, List<Chromosome> chromosomes)
throws IOException {
CloseableIterator<Alignment> iter = null;
AlignmentReader reader = null;
PrintWriter pw = null;
HashSet allChroms = new HashSet(chromosomes);
try {
pw = new PrintWriter(new FileWriter(outputFile));
reader = AlignmentReaderFactory.getReader(inputBam, false);
iter = reader.iterator();
while (iter.hasNext()) {
Alignment alignment = iter.next();
ReadMate mate = alignment.getMate();
// Filter unpaired and "normal" pairs. Only interested in abnormals
if (alignment.isPaired()
&& alignment.isMapped()
&& alignment.getMappingQuality() > 10
&& mate != null
&& mate.isMapped()
&& allChroms.contains(alignment.getChr())
&& allChroms.contains(mate.getChr())
&& (!alignment.getChr().equals(mate.getChr())
|| alignment.getInferredInsertSize() > 1000)) {
// Each pair is represented twice in the file, keep the record with the "leftmost"
// coordinate
if (alignment.getStart() < mate.getStart()) {
String strand = alignment.isNegativeStrand() ? "-" : "+";
String mateStrand = mate.isNegativeStrand() ? "-" : "+";
pw.println(
alignment.getReadName()
+ "\t"
+ alignment.getChr()
+ "\t"
+ alignment.getStart()
+ "\t"
+ strand
+ "\t.\t"
+ mate.getChr()
+ "\t"
+ mate.getStart()
+ "\t"
+ mateStrand);
}
}
}
} finally {
pw.close();
iter.close();
reader.close();
}
}
public static void main(String[] args) {
if (args.length != 1) {
System.err.println("Usage: Generator number_of_data.");
System.exit(-1);
}
Random rand = new Random();
int numberOfObjects = new Integer(args[0]).intValue();
HashMap data = new HashMap(numberOfObjects);
for (int i = 0; i < numberOfObjects; i++) {
MyRegion r =
new MyRegion(rand.nextDouble(), rand.nextDouble(), rand.nextDouble(), rand.nextDouble());
data.put(new Integer(i), r);
System.out.println(
"1 " + i + " " + r.m_xmin + " " + r.m_ymin + " " + r.m_xmax + " " + r.m_ymax);
}
int A = (int) (Math.floor((double) numberOfObjects * 0.1));
for (int T = 100; T > 0; T--) {
System.err.println(T);
HashSet examined = new HashSet();
for (int a = 0; a < A; a++) {
// find an id that is not yet examined.
Integer id = new Integer((int) ((double) numberOfObjects * rand.nextDouble()));
boolean b = examined.contains(id);
while (b) {
id = new Integer((int) ((double) numberOfObjects * rand.nextDouble()));
b = examined.contains(id);
}
examined.add(id);
MyRegion r = (MyRegion) data.get(id);
System.out.println(
"0 " + id + " " + r.m_xmin + " " + r.m_ymin + " " + r.m_xmax + " " + r.m_ymax);
r =
new MyRegion(
rand.nextDouble(), rand.nextDouble(), rand.nextDouble(), rand.nextDouble());
data.put(id, r);
System.out.println(
"1 " + id + " " + r.m_xmin + " " + r.m_ymin + " " + r.m_xmax + " " + r.m_ymax);
}
double stx = rand.nextDouble();
double sty = rand.nextDouble();
System.out.println("2 9999999 " + stx + " " + sty + " " + (stx + 0.01) + " " + (sty + 0.01));
}
}
protected String makeConstraintName(String consName) throws SchemaException {
boolean prev_constr = constraintList.contains(consName);
if (prev_constr) { // need to find new name --
Debugger.trace("Changing duplicate constraint name " + consName, Debugger.SHORT);
int i = 1;
while (constraintList.contains(consName + i)) i++;
consName += i;
}
constraintList.add(consName);
return consName;
}
public LinkedHashSet<Path> scan(FileSystem fs, Path filePath, Set<String> consumedFiles) {
LinkedHashSet<Path> pathSet = Sets.newLinkedHashSet();
try {
LOG.debug("Scanning {} with pattern {}", filePath, this.filePatternRegexp);
FileStatus[] files = fs.listStatus(filePath);
for (FileStatus status : files) {
Path path = status.getPath();
String filePathStr = path.toString();
if (consumedFiles.contains(filePathStr)) {
continue;
}
if (ignoredFiles.contains(filePathStr)) {
continue;
}
if (acceptFile(filePathStr)) {
LOG.debug("Found {}", filePathStr);
pathSet.add(path);
} else {
// don't look at it again
ignoredFiles.add(filePathStr);
}
}
} catch (FileNotFoundException e) {
LOG.warn("Failed to list directory {}", filePath, e);
} catch (IOException e) {
throw new RuntimeException(e);
}
return pathSet;
}
/**
* Return top K authorities (result from SALSA), but do not include users in the removeList
*
* @param K
* @param removeList
* @return
*/
public ArrayList<SalsaVertex> topAuthorities(int K, HashSet<Integer> removeList) {
// TODO: faster top-K implementation
ArrayList<SalsaVertex> all = new ArrayList<SalsaVertex>(authorities.size());
all.addAll(authorities.values());
Collections.sort(
all,
new Comparator<SalsaVertex>() {
@Override
public int compare(SalsaVertex salsaVertex, SalsaVertex salsaVertex1) {
if (salsaVertex.value < salsaVertex1.value) return 1;
else return (salsaVertex.value > salsaVertex1.value ? -1 : 0);
}
});
ArrayList<SalsaVertex> result = new ArrayList<SalsaVertex>(K);
int i = 0;
while (result.size() < K) {
if (i < all.size()) {
SalsaVertex x = all.get(i);
if (!removeList.contains(x.id)) result.add(x);
} else {
break;
}
i++;
}
return result;
}
/**
* Updates the information in the friend list about a player if that player is a friend
*
* @param friend The player
*/
public static void updateFriend(final Player friend) {
synchronized (monitor) {
if (friends.contains(friend) == false) return;
saveFriends();
}
}
public ArrayList<CellTagPair> findMarkupTags() {
Pattern tagPattern = Pattern.compile("\\{(.+?)\\}");
ArrayList<CellTagPair> result = new ArrayList<CellTagPair>();
int width = getWidth();
int height = getHeight();
for (int y = 0; y < height; y++) {
for (int x = 0; x < width - 3; x++) {
Cell cell = new Cell(x, y);
char c = get(cell);
if (c == '{') {
String rowPart = rows.get(y).substring(x);
Matcher matcher = tagPattern.matcher(rowPart);
if (matcher.find()) {
String tagName = matcher.group(1);
if (markupTags.contains(tagName)) {
if (DEBUG) System.out.println("found tag " + tagName + " at " + x + ", " + y);
result.add(new CellTagPair(new Cell(x, y), tagName));
}
}
}
}
}
return result;
}
static void runTest(HashSet<Integer> caseSet) {
int cases = 0, passed = 0;
while (true) {
String label = Reader.nextLine();
if (label == null || !label.startsWith("--")) break;
int N = Integer.parseInt(Reader.nextLine());
Reader.nextLine();
double __answer = Double.parseDouble(Reader.nextLine());
cases++;
if (caseSet.size() > 0 && !caseSet.contains(cases - 1)) continue;
System.err.print(String.format(" Testcase #%d ... ", cases - 1));
if (doTest(N, __answer)) passed++;
}
if (caseSet.size() > 0) cases = caseSet.size();
System.err.println(String.format("%nPassed : %d/%d cases", passed, cases));
int T = (int) (System.currentTimeMillis() / 1000) - 1398529188;
double PT = T / 60.0, TT = 75.0;
System.err.println(
String.format(
"Time : %d minutes %d secs%nScore : %.2f points",
T / 60, T % 60, 950 * (0.3 + (0.7 * TT * TT) / (10.0 * PT * PT + TT * TT))));
}
public static void main(String args[]) throws Exception {
HashSet<String> hs = new HashSet<String>();
FileReader fr1 = new FileReader("sample.txt");
BufferedReader br = new BufferedReader(fr1);
String s;
while ((s = br.readLine()) != null) {
hs.add(s);
}
fr1.close();
FileReader fr2 = new FileReader("input.txt");
br = new BufferedReader(fr2);
while ((s = br.readLine()) != null) {
Scanner ip = new Scanner(s);
String word;
while (ip.hasNext()) {
word = ip.next();
if (hs.contains(word)) ;
else System.out.print(word + " ");
}
}
fr2.close();
}
public static void printViewPatterns() {
processedViewsForPatterns = new HashSet<ViewTrace>();
HashMap<String, Integer> viewPatterns = new HashMap<String, Integer>();
ps.println("ViewPatterns ------------------- \n");
for (ViewTrace trace : viewsRegistry) {
if (processedViewsForPatterns.contains(trace)) {
continue;
}
ViewTrace v = trace.getRootView();
StringBuilder p = new StringBuilder();
p.append("PATTERN ");
extractViewPattern(0, v, p);
p.append("\n");
String pattern = p.toString();
Integer count = viewPatterns.get(pattern);
if (count == null) {
viewPatterns.put(pattern, 1);
} else {
viewPatterns.put(pattern, count + 1);
}
}
processedViewsForPatterns = null;
for (Map.Entry<String, Integer> e : viewPatterns.entrySet()) {
ps.print("(" + e.getValue() + ") ");
ps.println(e.getKey());
}
}
protected void writeAttributes(DOMOutput out) throws IOException {
Figure prototype = (Figure) out.getPrototype();
boolean isElementOpen = false;
for (Map.Entry<AttributeKey, Object> entry : attributes.entrySet()) {
AttributeKey key = entry.getKey();
if (forbiddenAttributes == null || !forbiddenAttributes.contains(key)) {
Object prototypeValue = key.get(prototype);
Object attributeValue = key.get(this);
if (prototypeValue != attributeValue
|| (prototypeValue != null
&& attributeValue != null
&& !prototypeValue.equals(attributeValue))) {
if (!isElementOpen) {
out.openElement("a");
isElementOpen = true;
}
out.openElement(key.getKey());
out.writeObject(entry.getValue());
out.closeElement();
}
}
}
if (isElementOpen) {
out.closeElement();
}
}
public void init() {
Scanner scan = new Scanner(System.in);
n = scan.nextInt();
m = scan.nextInt();
for (int i = 0; i < n; i++) {
String input = scan.next();
record.add(input);
}
for (int i = 0; i < m; i++) {
String input = scan.next();
char[] charArray = input.toCharArray();
boolean isValid = false;
for (int j = 0; j < charArray.length; j++) {
char c = charArray[j];
for (char d = 'a'; d <= 'c'; d = (char) (d + 1)) {
if (d == c) continue;
charArray[j] = d;
if (record.contains(new String(charArray))) {
isValid = true;
break;
}
}
charArray[j] = c;
if (isValid) break;
}
if (isValid) System.out.println("YES");
else System.out.println("NO");
}
scan.close();
}
public static void printSite(Site s, StringBuilder out) {
if (s == null) {
out.append("(null)");
return;
}
StackTraceElement[] st = s.site();
int interestingSitesPrinted = 0;
for (int i = s.offset; i < st.length; i++) {
StackTraceElement e = st[i];
String fileName = e.getFileName();
if (THIS_FILE_NAME.equals(fileName)) {
continue;
}
out.append(" " + e.getMethodName() + "(" + e.getFileName() + ":" + e.getLineNumber() + ")");
interestingSitesPrinted++;
if (interestingSitesPrinted <= SITES_TO_PRINT) {
continue;
}
if (fileName == null || "View.java".equals(fileName)) {
continue;
}
String methodName = e.getMethodName();
if (skipMethods.contains(methodName)) {
continue;
}
break;
}
}
/**
* Chooses tokens from the file cache that match the specified pattern.
*
* @param pattern file pattern
* @param search search string
* @param mode search mode (0-2)
* @param results search result
* @param exclude exclude file from content search
* @param pathSearch path flag
* @param pc file cache
* @param id search id
* @throws InterruptedException interruption
*/
private void filter(
final String pattern,
final int[] search,
final int mode,
final TreeSet<String> results,
final HashSet<String> exclude,
final boolean pathSearch,
final ProjectCache pc,
final long id)
throws InterruptedException {
if (results.size() >= MAXHITS) return;
for (final String path : pc) {
// check if current file matches the pattern
final String lc = path.toLowerCase(Locale.ENGLISH).replace('\\', '/');
final int offset = offset(lc, pathSearch);
if (mode == 0
? lc.startsWith(pattern, offset)
: mode == 1 ? (lc.indexOf(pattern, offset) != -1) : matches(lc, pattern, offset)) {
if (!exclude.contains(path)) {
exclude.add(path);
if (filterContent(path, search)) {
results.add(path);
if (results.size() >= MAXHITS) return;
}
}
}
if (id != filterId) throw new InterruptedException();
}
}
static Method[] getOverridableMethods(Class c) {
ArrayList<Method> list = new ArrayList<Method>();
HashSet<String> skip = new HashSet<String>();
while (c != null) {
Method[] methods = c.getDeclaredMethods();
for (int i = 0; i < methods.length; i++) {
String methodKey =
methods[i].getName() + getMethodSignature(methods[i], methods[i].getParameterTypes());
if (skip.contains(methodKey)) continue; // skip this method
int mods = methods[i].getModifiers();
if (Modifier.isStatic(mods)) continue;
if (Modifier.isFinal(mods)) {
// Make sure we don't add a final method to the list
// of overridable methods.
skip.add(methodKey);
continue;
}
if (Modifier.isPublic(mods) || Modifier.isProtected(mods)) {
list.add(methods[i]);
skip.add(methodKey);
}
}
c = c.getSuperclass();
}
return list.toArray(new Method[list.size()]);
}
/**
* Overwrite this method if you want to filter the input, apply hashing, etc.
*
* @param feature the current feature.
* @param document the current document.
* @param featureFieldName the field hashFunctionsFileName of the feature.
*/
protected void addToDocument(LireFeature feature, Document document, String featureFieldName) {
if (run == 0) {
} // just count documents
else if (run == 1) { // Select the representatives ...
if (representativesID.contains(docCount)
&& feature
.getClass()
.getCanonicalName()
.equals(featureClass.getCanonicalName())) { // it's a representative.
// put it into a temporary data structure ...
representatives.add(feature);
}
} else if (run
== 2) { // actual hashing: find the nearest representatives and put those as a hash into a
// document.
if (feature
.getClass()
.getCanonicalName()
.equals(featureClass.getCanonicalName())) { // it's a feature to be hashed
int[] hashes = getHashes(feature);
document.add(
new TextField(
featureFieldName + "_hash",
createDocumentString(hashes, hashes.length),
Field.Store.YES));
document.add(
new TextField(
featureFieldName + "_hash_q", createDocumentString(hashes, 10), Field.Store.YES));
}
document.add(new StoredField(featureFieldName, feature.getByteArrayRepresentation()));
}
}
/**
* Adds a player to the friend list
*
* @param friend The player
*/
public static void addFriend(final Player friend) {
synchronized (monitor) {
if (friends.contains(friend)) return;
friends.add(friend);
saveFriends();
}
}
public static void main(String[] args) {
StringKeyLinkedMap<Object> defMap = ConfigValueUtil.getConfigDefault(new Configure(true));
StringEnumer enu = defMap.keys();
while (enu.hasMoreElements()) {
String key = enu.nextString();
if (ignoreSet.contains(key)) continue;
System.out.println(key + " : " + ConfigValueUtil.toValue(defMap.get(key)));
}
}
//
// Returns true if this method is allowed to raise SQLFeatureNotSupportedException.
//
private boolean isExcludable(Method method) throws Exception {
Class iface = method.getDeclaringClass();
HashSet<Method> excludableMethods = excludableMap.get(iface);
if (excludableMethods == null) {
return false;
}
return excludableMethods.contains(method);
}
/**
* Garbage collect repository
*
* @throws Exception
*/
public void gc() throws Exception {
HashSet<byte[]> deps = new HashSet<byte[]>();
// deps.add(SERVICE_JAR_FILE);
for (File cmd : commandDir.listFiles()) {
CommandData data = getData(CommandData.class, cmd);
addDependencies(deps, data);
}
for (File service : serviceDir.listFiles()) {
File dataFile = new File(service, "data");
ServiceData data = getData(ServiceData.class, dataFile);
addDependencies(deps, data);
}
int count = 0;
for (File f : repoDir.listFiles()) {
String name = f.getName();
if (!deps.contains(name)) {
if (!name.endsWith(".json")
|| !deps.contains(name.substring(0, name.length() - ".json".length()))) { // Remove
// json
// files
// only
// if
// the
// bin
// is
// going
// as
// well
f.delete();
count++;
} else {
}
}
}
System.out.format("Garbage collection done (%d file(s) removed)%n", count);
}
// Returns true iff all items in subset are in superset, treating null and
// empty collections as
// the same.
public static <T> boolean isSubset(Collection<T> subset, Collection<T> superset) {
if ((superset == null) || (superset.size() == 0)) {
return ((subset == null) || (subset.size() == 0));
}
HashSet<T> hash = new HashSet<T>(superset);
for (T t : subset) {
if (!hash.contains(t)) {
return false;
}
}
return true;
}
public boolean hashSetContainsSameOperations(HashSet set1, HashSet set2) {
boolean result = false;
HashSet s1 = (HashSet) set1.clone();
HashSet s2 = (HashSet) set2.clone();
// first part, are all elements of s1 also in s2?
boolean one = false;
Iterator it = set1.iterator();
while (it.hasNext()) {
PDMOperation d = (PDMOperation) it.next();
if (s2.contains(d)) {
s1.remove(d);
}
}
if (s1.isEmpty()) {
one = true;
}
// second part, are all elements of s21 also in s1?
boolean two = false;
HashSet s3 = (HashSet) set1.clone();
HashSet s4 = (HashSet) set2.clone();
Iterator it2 = set2.iterator();
while (it2.hasNext()) {
PDMOperation d = (PDMOperation) it2.next();
if (s3.contains(d)) {
s4.remove(d);
}
}
if (s4.isEmpty()) {
two = true;
}
// administrative stuff
s1.clear();
s2.clear();
s3.clear();
s4.clear();
result = one && two;
return result;
}
public static void printIndividualViews() {
printedIndividualViews = new HashSet<ViewTrace>();
ps.println("Individual views statistics ------------------- \n");
for (ViewTrace trace : viewsRegistry) {
if (printedIndividualViews.contains(trace)) {
continue;
}
ViewTrace v = trace.getRootView();
ps.print("ROOT ");
dumpView(0, v);
ps.println();
}
printViewPatterns();
printedIndividualViews = null;
}
Schema computeAvroSchema() {
HashSet<String> observedSchemas = new HashSet<String>();
List<Schema> fields = new ArrayList<Schema>();
for (InferredType it : unionTypes) {
Schema itS = it.getAvroSchema();
if (itS == null) {
continue;
}
String schemaDesc = itS.toString();
if (!observedSchemas.contains(schemaDesc)) {
observedSchemas.add(schemaDesc);
fields.add(it.getAvroSchema());
}
}
return Schema.createUnion(fields);
}
/*
* returns # of valid words given message and dictionary against which to check words in
* the message. Lowercases the word before checking in dictionary
*/
public int countWords(String message, HashSet<String> dictionary) {
int validWords = 0;
int totalWords = 0;
// split the message into words
for (String word : message.split("\\W")) {
totalWords++;
word = word.toLowerCase();
if (dictionary.contains(word)) {
validWords++;
}
}
System.out.println("total words: " + totalWords + " valid words: " + validWords);
return validWords;
}
synchronized void updateAll() {
HashSet<Node> seenNodes = new HashSet<Node>();
for (int i = 0; i < _all.size(); i++) {
Node n = _all.get(i);
n.update(seenNodes);
}
if (!seenNodes.isEmpty()) {
// not empty, means that at least 1 server gave node list
// remove unused hosts
Iterator<Node> it = _all.iterator();
while (it.hasNext()) {
if (!seenNodes.contains(it.next())) it.remove();
}
}
}
public int count(int[] seq, int bound) {
HashSet<String> set = new HashSet<String>();
HashSet<Integer> nums = new HashSet<Integer>();
int n = seq.length;
for (int i = 0; i < n; i++) {
nums.add(seq[i]);
}
int t = nums.size();
int total = 0;
nums.add(-1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int x : nums) {
int seq2[] = seq.clone();
if (i < j) {
for (int k = i + 1; k < j + 1; k++) {
seq2[k - 1] = seq2[k];
}
} else if (i > j) {
for (int k = i; k > j; k--) {
seq2[k] = seq2[k - 1];
}
}
seq2[j] = x;
String key = Arrays.toString(seq2);
if (!set.contains(key)) {
if (x == -1) {
total += bound - t;
} else {
total++;
}
total %= MOD;
set.add(key);
}
}
}
}
return total;
}
public MapValue getKeyValueInfo() {
StringKeyLinkedMap<Object> defMap = ConfigValueUtil.getConfigDefault(new Configure(true));
StringKeyLinkedMap<Object> curMap = ConfigValueUtil.getConfigDefault(this);
MapValue m = new MapValue();
ListValue nameList = m.newList("key");
ListValue valueList = m.newList("value");
ListValue defList = m.newList("default");
StringEnumer enu = defMap.keys();
while (enu.hasMoreElements()) {
String key = enu.nextString();
if (ignoreSet.contains(key)) continue;
nameList.add(key);
valueList.add(ConfigValueUtil.toValue(curMap.get(key)));
defList.add(ConfigValueUtil.toValue(defMap.get(key)));
}
return m;
}
void solve() throws IOException {
int[] gr = new int[5001];
for (int i = 1; i < 5001; i++) {
HashSet<Integer> s = new HashSet<Integer>();
for (int j = 1; j + j <= i; j++) {
s.add(gr[i - j]);
}
for (int t = 0; t <= s.size(); t++) {
if (!s.contains(t)) {
gr[i] = t;
break;
}
}
}
/*for (int i = 0;i < 1000; i++) {
out.println(i + " " + gr[i]);
}*/
int a = nextInt();
int b = nextInt();
int c = nextInt();
int ans = gr[a] ^ gr[b] ^ gr[c];
if (ans == 0) {
out.println("NO");
} else {
out.println("YES");
for (int i = 1; i + i <= a; i++) {
if ((gr[a - i] ^ gr[b] ^ gr[c]) == 0) {
out.println((a - i) + " " + b + " " + c);
return;
}
}
for (int i = 1; i + i <= b; i++) {
if ((gr[a] ^ gr[b - i] ^ gr[c]) == 0) {
out.println(a + " " + (b - i) + " " + c);
return;
}
}
for (int i = 1; i + i <= c; i++) {
if ((gr[a] ^ gr[b] ^ gr[c - i]) == 0) {
out.println(a + " " + b + " " + (c - i));
return;
}
}
}
}
@SuppressWarnings("unchecked")
protected void readAttributes(DOMInput in) throws IOException {
if (in.getElementCount("a") > 0) {
in.openElement("a");
for (int i = in.getElementCount() - 1; i >= 0; i--) {
in.openElement(i);
String name = in.getTagName();
Object value = in.readObject();
AttributeKey key = getAttributeKey(name);
if (key != null && key.isAssignable(value)) {
if (forbiddenAttributes == null || !forbiddenAttributes.contains(key)) {
setAttribute(key, value);
}
}
in.closeElement();
}
in.closeElement();
}
}
