java第十次作业

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
public class Main {
public static void apriori(int paramInt, String[][] paramArrayOfString) {
String str;
Object localObject;
TreeMap<String,Object> localTreeMap = new TreeMap<String,Object>();
for (int i = 0; i < paramArrayOfString.length; ++i)
for (int j = 0; j < paramArrayOfString[i].length; ++j) {
str = paramArrayOfString[i][j];
localObject = (Integer) localTreeMap.get(str);
localTreeMap.put(str, Integer.valueOf((localObject == null) ? 1 : ((Integer) localObject).intValue() + 1));
}

ArrayList<String> localArrayList = new ArrayList<String>();

for (Iterator<String> localIterator = localTreeMap.keySet().iterator(); localIterator.hasNext();) {
str =  localIterator.next();
if (((Integer) localTreeMap.get(str)).intValue() >= paramInt)
localArrayList.add(str);
}
for (int k = 0; k < localArrayList.size(); ++k)
for (int l = k + 1; l < localArrayList.size(); ++l) {
Set<String> localSet = new HashSet<String>();
localSet.add(localArrayList.get(k));
localSet.add(localArrayList.get(l));
int i1 = getSupport(localSet, paramArrayOfString);
if (i1 >= paramInt)
StdOut.printf("%s,%s:%d\n", new Object[] { localArrayList.get(k), localArrayList.get(l), Integer.valueOf(i1) });
}
}

public static int getSupport(Set<String> paramSet, java.lang.String[][] paramArrayOfString) {
int i = 0;

for (int j = 0; j < paramArrayOfString.length; ++j) {
int k = 1;
for (Iterator<String> localIterator = paramSet.iterator(); localIterator.hasNext();) {
String str =  localIterator.next();
int l = 0;
for (int i1 = 0; i1 < paramArrayOfString[j].length; ++i1)
if (str.equals(paramArrayOfString[j][i1])) {
l = 1;
break;
}
if (l == 0) {
k = 0;
break;
}
}
if (k != 0)
++i;
}

return i;
}
public static void main(java.lang.String[] paramArrayOfString) throws Exception {
int i = StdIn.readInt();
int j = StdIn.readInt();
StdIn.readLine();
String[][] arrayOfString = new String[j][];
for (int k = 0; k < j; ++k) {
String str = StdIn.readLine();
arrayOfString[k] = str.split(",");
}
apriori(i, arrayOfString);
}
}

import java.util.HashMap;
public class Main {
public static void main(String[] args) throws Exception {
HashMap<String, Object> localHashMap = new HashMap<String, Object>();
String str1 = StdIn.readLine();
while (true) {
while (true) {
if (StdIn.isEmpty())
return;
str1 = StdIn.readLine();
if (str1.charAt(0) == '#')
break;
String[] arrayOfString = str1.split(",");
String str2 = arrayOfString[0];
String localObject = arrayOfString[1];
int i = Integer.parseInt(arrayOfString[2]);
String str3 = arrayOfString[3];
double d = Double.parseDouble(arrayOfString[4]);
Element localElement = new Element(str2, localObject, i, str3, d);
localHashMap.put(str3, localElement);
}
String[] arrayOfString = str1.split(",");
String str2 = arrayOfString[0].substring(1);
Object localObject = (Element) localHashMap.get(str2);
StdOut.println(localObject);
}
}
}

class Element {
private String cname;
private String ename;
private int number;
private String symbol;
private double weight;

public Element(String paramString1, String paramString2, int paramInt, String paramString3, double paramDouble) {
this.cname = paramString1;
this.ename = paramString2;
this.number = paramInt;
this.symbol = paramString3;
this.weight = paramDouble;
}

public String toString() {
String str = "";
str = str + this.cname + " " + this.ename + " (" + this.symbol + ")    ";
str = str + this.number + "    " + this.weight;
return str;
}
}

import java.util.Arrays;
public class Main {
public static void main(String[] args) throws Exception {
String str = StdIn.readAll();
str = str.toLowerCase();
str = str.replaceAll("[\\d\",!.:;?()`'*-]", "");
String[] arrayOfString = str.split("\\s+");
Arrays.sort(arrayOfString);
Counter[] arrayOfCounter = new Counter[arrayOfString.length];
int i = 0;
for (int j = 0; j < arrayOfString.length; ++j) {
if ((j == 0) || (!(arrayOfString[j].equals(arrayOfString[(j - 1)]))))
arrayOfCounter[(i++)] = new Counter(arrayOfString[j], arrayOfString.length);
arrayOfCounter[(i - 1)].increment();
}

Arrays.sort(arrayOfCounter, 0, i);
for (int j = i - 1; j >= Math.max(i - 10, 0); --j)
StdOut.println(arrayOfCounter[j]);
}
}

class Counter implements Comparable<Counter> {
private final String name;
private final int maxCount;
private int count;

public Counter(String paramString, int paramInt) {
this.name = paramString;
this.maxCount = paramInt;
this.count = 0;
}

public void increment() {
if (this.count < this.maxCount)
this.count += 1;
}

public int value() {
return this.count;
}

public String toString() {
return this.name + ":" + this.count;
}

public int compareTo(Counter paramCounter) {
if (this.count < paramCounter.count)
return -1;
if (this.count > paramCounter.count)
return 1;
return 0;
}
}