public void prepare(ColumnFamilyStore cfs) { if (tree.partitioner() instanceof RandomPartitioner) { // You can't beat an even tree distribution for md5 tree.init(); } else { List<DecoratedKey> keys = new ArrayList<DecoratedKey>(); for (DecoratedKey sample : cfs.keySamples(request.range)) { assert request.range.contains(sample.token) : "Token " + sample.token + " is not within range " + request.range; keys.add(sample); } if (keys.isEmpty()) { // use an even tree distribution tree.init(); } else { int numkeys = keys.size(); Random random = new Random(); // sample the column family using random keys from the index while (true) { DecoratedKey dk = keys.get(random.nextInt(numkeys)); if (!tree.split(dk.token)) break; } } } logger.debug("Prepared AEService tree of size " + tree.size() + " for " + request); ranges = tree.invalids(); }
public static void main(String[] args) throws FileNotFoundException { /* Loads the word list and stores its length */ String ext = "/afs/cats/courses/cmps109-db/cmps012a-pa1/wordList.txt"; Scanner in = new Scanner(new FileInputStream(ext)); int listSize = in.nextInt(); // length of the word list /* Randomly selects word from the word list */ Random rand = new Random(); int n = rand.nextInt(listSize) + 1; for (int i = 1; i < n; i++) in.next(); String word = in.next(); /* Displays to the user the number of letters in the word */ System.out.println("Your word is " + word.length() + " letters long."); /* Recursive method that plays the game. TRUE return indicates win */ if (play(word)) { System.out.println("You win! The word was " + word + "."); } else { // Display for if the user loses System.out.println("You lose. The word was " + word + "."); } }
public int choiceOneCard(Player self) { // 幫我看一下self用法是不是錯了 Random ran = new Random(); int cardNo = ran.nextInt(self.hand.size()); // 表示第幾張牌 int cardId = self.hand.get(cardNo); // 表示值 self.hand.remove(cardNo); return cardId; }
/** * Base tick method for the level. Updates all entities, tiles, and player. Has slow repopulation * algorithm */ public void tick() { player.tick(); List<Entity> toTick = new ArrayList<Entity>(); int lr = 7; for (int x = -lr; x < lr; x++) { for (int y = -lr; y < lr; y++) { Tile tile = getTile(player.x + x, player.z + y); tile.addToTick(toTick); tile.tick(); } } for (int i = 0; i < toTick.size(); i++) { Entity e = toTick.get(i); e.tick(this); } tickcount++; if (tickcount % 1800 == 0) { System.out.println("Adding entity to world"); if (r != null) { int rx = r.nextInt(w); int ry = r.nextInt(h); if (skillNoise.noise(rx / 80d, ry / 80d) > 0.0) { SmallMob mob = new SmallMob(); if (!tiles[rx + ry * w].blocks(mob)) { tiles[rx + ry * w].addEntity(r.nextInt(4), mob); } } } } }
public void testFormat() throws Exception { localFs = FileSystem.getLocal(defaultConf); localFs.delete(workDir, true); Job job = new Job(new Configuration(defaultConf)); Path file = new Path(workDir, "test.txt"); int seed = new Random().nextInt(); Random random = new Random(seed); // for a variety of lengths for (int length = 0; length < MAX_LENGTH; length += random.nextInt(MAX_LENGTH / 10) + 1) { // create a file with length entries Writer writer = new OutputStreamWriter(localFs.create(file)); try { MyClass mc = new MyClass(); for (int i = 0; i < length; i++) { mc.s = Integer.toString(i); mc.v = i; byte[] raw = MessagePack.pack(mc); byte[] b64e = base64_.encodeBase64(raw); byte[] b64d = base64_.decode(b64e); MyClass mc2 = MessagePack.unpack(b64d, mc.getClass()); assertEquals(mc.s, mc2.s); assertEquals(mc.v, mc2.v); writer.write(base64_.encodeToString(raw)); } } finally { writer.close(); } checkFormat(job); } }
/** * Tests offset and limit clauses for query. * * @throws Exception If failed. */ public void testOffsetLimit() throws Exception { IgniteCache<Integer, Integer> c = ignite(0).getOrCreateCache(cacheConfig("ints", true, Integer.class, Integer.class)); try { List<Integer> res = new ArrayList<>(); Random rnd = new GridRandom(); for (int i = 0; i < 10; i++) { int val = rnd.nextInt(100); c.put(i, val); res.add(val); } Collections.sort(res); String qry = "select _val from Integer order by _val "; assertEqualsCollections(res, columnQuery(c, qry)); assertEqualsCollections(res.subList(0, 0), columnQuery(c, qry + "limit ?", 0)); assertEqualsCollections(res.subList(0, 3), columnQuery(c, qry + "limit ?", 3)); assertEqualsCollections(res.subList(0, 9), columnQuery(c, qry + "limit ? offset ?", 9, 0)); assertEqualsCollections(res.subList(3, 7), columnQuery(c, qry + "limit ? offset ?", 4, 3)); assertEqualsCollections(res.subList(7, 9), columnQuery(c, qry + "limit ? offset ?", 2, 7)); assertEqualsCollections(res.subList(8, 10), columnQuery(c, qry + "limit ? offset ?", 2, 8)); assertEqualsCollections(res.subList(9, 10), columnQuery(c, qry + "limit ? offset ?", 1, 9)); assertEqualsCollections(res.subList(10, 10), columnQuery(c, qry + "limit ? offset ?", 1, 10)); assertEqualsCollections( res.subList(9, 10), columnQuery(c, qry + "limit ? offset abs(-(4 + ?))", 1, 5)); } finally { c.destroy(); } }
static void genRandom(int cnt, int value) throws IOException { ArrayList<Integer> ch = new ArrayList<Integer>(); ch.add(rand.nextInt(value / cnt)); for (int i = 1; i < cnt; i++) ch.add(rand.nextInt(value / cnt) + 1 + ch.get(i - 1)); crypto(ch); print(); }
public static void golf(String file_name) { Random rand = new Random(); ArrayList<Person> players = new ArrayList(); try { Scanner in = new Scanner(new FileReader(file_name)); while (in.hasNextLine()) { String name = in.nextLine(); Person person = new Person(name); players.add(person); } } catch (Exception e) { System.out.println("Could not find file"); } while (!players.isEmpty()) { int first, second; do { first = rand.nextInt(players.size()); second = rand.nextInt(players.size()); } while (first == second); System.out.println("Team:"); System.out.println(players.get(first).name); System.out.println(players.get(second).name); System.out.print("\n"); players.remove(second); if (second < first) { players.remove(first - 1); } else { players.remove(first); } } }
/** * Returns the index of the piece that could be downloaded by the peer in parameter * * @param id The id of the peer that wants to download * @return int The index of the piece to request */ private synchronized int choosePiece2Download(String id) { synchronized (this.isComplete) { int index = 0; ArrayList<Integer> possible = new ArrayList<Integer>(this.nbPieces); for (int i = 0; i < this.nbPieces; i++) { if ((!this.isPieceRequested(i) || (this.isComplete.cardinality() > this.nbPieces - 3)) && // (this.isRequested.cardinality() == this.nbPieces)) && (!this.isPieceComplete(i)) && this.peerAvailabilies.get(id) != null) { if (this.peerAvailabilies.get(id).get(i)) possible.add(i); } } // System.out.println(this.isRequested.cardinality()+" "+this.isComplete.cardinality()+" " + // possible.size()); if (possible.size() > 0) { Random r = new Random(System.currentTimeMillis()); index = possible.get(r.nextInt(possible.size())); this.setRequested(index, true); return (index); } return -1; } }
static StringDoubleMap test(int n, int range) { // Generate random data Random rand = new Random(); Set<Integer> set = new HashSet<Integer>(); for (int i = 0; i < n; i++) set.add(rand.nextInt(range)); // Make the map StringDoubleMap map = new StringDoubleMap(0); // map.switchToSortedList(); for (int x : set) { map.put("" + x, 1.0 * x); } // System.out.println("here"); check(set, map); map.switchToSortedList(); check(set, map); map.switchToHashTable(); check(set, map); map.lock(); for (int x : set) map.put("" + x, 1.0 * x); assert set.size() == map.size(); return map; }
public static void main(String[] args) { Random r = new Random(); int n; if (args.length == 1) { n = Integer.parseInt(args[0]); } else { n = r.nextInt(10000) + 1; } try { OutputStream ofs = new FileOutputStream("scores.txt"); ObjectOutputStream oos = new ObjectOutputStream(ofs); for (int i = 0; i < n; ++i) { int testNum = r.nextInt(21); String name = randString(r.nextInt(6) + 5); while (testNum-- > 0) { oos.writeUTF(name); oos.writeInt(r.nextInt(101)); } } ofs.close(); } catch (Exception e) { System.out.println("Error creating scores.txt: " + e.getMessage()); } try { InputStream ifs = new FileInputStream("scores.txt"); String name = findStudentWithTopThreeAverageScores(ifs); System.out.println("top student is " + name); ifs.close(); } catch (Exception e) { System.out.println("Error reading scores.txt: " + e.getMessage()); } }
private void addFeed() { if (isEnd) return; if (isFeed) return; feedX = Math.abs(random.nextInt()) % 400 + 10; feedY = Math.abs(random.nextInt()) % 400 + 60; List<Block> blockTemp = new ArrayList<>(blocks); for (int i = 0; i < blockTemp.size(); i++) if (blockTemp.get(i).getX() < feedX && blockTemp.get(i).getY() < feedY && blockTemp.get(i).getX() + 10 > feedX && blockTemp.get(i).getY() + 10 > feedY) { feedX = Math.abs(random.nextInt()) % 400 + 10; feedY = Math.abs(random.nextInt()) % 400 + 60; } feedRectangle.setX(feedX); feedRectangle.setY(feedY); isFeed = true; addObstacle(); }
private Card genNewCard() { Random rand = new Random(); Card card = new Card(rand.nextInt(52) + 1); while (cardUsed.contains(card)) card = new Card(rand.nextInt(52) + 1); cardUsed.add(card); return card; }
/** * Gera uma partícula aleatória de dimensões fixas. * * <p>Define os valores para size, maxValue, dimensions, lBest e inertia. * * @param pagesArray array com as páginas do banco de dados * @param size quantidade de dimensões da partícula */ public Particle(int[] pagesArray, int size, int inertia, Random r) throws IOException { maxValue = pagesArray.length; dimensions = new int[size]; velocity = new int[size]; lBest = new int[size]; this.inertia = inertia; this.rnd = r; for (int i = 0; i < size; i++) { dimensions[i] = (int) (rnd.nextFloat() * pagesArray.length); lBest[i] = (int) (rnd.nextFloat() * pagesArray.length); // System.out.println("dimensions["+i+"] : "+dimensions[i]); } File f = new File("dimensions"); FileWriter fw = new FileWriter(f, true); BufferedWriter bw = new BufferedWriter(fw); PrintWriter pw = new PrintWriter(bw); pw.println("pagesArray.length " + pagesArray.length); for (int i = 0; i < dimensions.length; i++) { pw.print(dimensions[i] + " "); } pw.println(); pw.close(); bw.close(); fw.close(); }
public static void createTestFiles() { try { System.out.println("Creating test files ... "); Random rand = new Random(); String rootname = "f-"; long[] sizes = {0, 1, 50000000}; File testdir = new File(dirname); FileUtil.mkdirs(testdir); for (int i = 0; i < sizes.length; i++) { long size = sizes[i]; File file = new File(testdir, rootname + String.valueOf(size)); System.out.println(file.getName() + "..."); FileChannel fc = new RandomAccessFile(file, "rw").getChannel(); long position = 0; while (position < size) { long remaining = size - position; if (remaining > 1024000) remaining = 1024000; byte[] buffer = new byte[new Long(remaining).intValue()]; rand.nextBytes(buffer); ByteBuffer bb = ByteBuffer.wrap(buffer); position += fc.write(bb); } fc.close(); } System.out.println("DONE\n"); } catch (Exception e) { Debug.printStackTrace(e); } }
public void attack(Character other) { Random r = new Random(); Scanner sc = new Scanner(System.in); int dex = dexterity; int mult = 1; int x = r.nextInt(6) + 1, y = r.nextInt(6) + 1, z = r.nextInt(6) + 1; System.out.println("\nChoose your weapon:\n1 - Dagger\n2 - Short sword"); System.out.print(">"); int weapon = sc.nextInt(); if (weapon == 1) { dex = dexterity + 3; mult = 2; } else if (weapon == 2) { dex = dexterity + 1; mult = 3; } System.out.println("\n" + this + " attacked!"); pause(); if (x + y + z <= dex) { int dmg = damageDone(other, mult); other.loseHealth(dmg); System.out.println("\n" + name + " did " + dmg + " damage to " + other + "!"); } else { System.out.println("\n" + name + " missed!"); } }
private void addRegime() { if (isEnd) return; if (feedCounter2 - feedCounter1 != 4 || isRegime || feedCounter2 == 0) return; feedCounter1 = feedCounter2; currentTime = System.currentTimeMillis(); regimeX = Math.abs(random.nextInt()) % 400 + 10; regimeY = Math.abs(random.nextInt()) % 400 + 10; List<Block> blockTemp = new ArrayList<>(blocks); for (int i = 0; i < blockTemp.size(); i++) if (blockTemp.get(i).getX() < regimeX && blockTemp.get(i).getY() < regimeY && blockTemp.get(i).getX() + 10 > regimeX && blockTemp.get(i).getY() + 10 > regimeY) { regimeX = Math.abs(random.nextInt()) % 400 + 10; regimeY = Math.abs(random.nextInt()) % 400 + 10; } regimeRectangle.setX(regimeX); regimeRectangle.setY(regimeY); isRegime = true; }
/** * Get a path from the local FS. If size is known, we go round-robin over the set of disks (via * the configured dirs) and return the first complete path which has enough space. * * <p>If size is not known, use roulette selection -- pick directories with probability * proportional to their available space. */ public synchronized Path getLocalPathForWrite( String pathStr, long size, Configuration conf, boolean checkWrite) throws IOException { confChanged(conf); int numDirs = localDirsPath.length; int numDirsSearched = 0; // remove the leading slash from the path (to make sure that the uri // resolution results in a valid path on the dir being checked) if (pathStr.startsWith("/")) { pathStr = pathStr.substring(1); } Path returnPath = null; Path path = new Path(pathStr); if (size == SIZE_UNKNOWN) { // do roulette selection: pick dir with probability // proportional to available size long[] availableOnDisk = new long[dirDF.length]; long totalAvailable = 0; // build the "roulette wheel" for (int i = 0; i < dirDF.length; ++i) { availableOnDisk[i] = dirDF[i].getAvailable(); totalAvailable += availableOnDisk[i]; } // Keep rolling the wheel till we get a valid path Random r = new java.util.Random(); while (numDirsSearched < numDirs && returnPath == null) { long randomPosition = Math.abs(r.nextLong()) % totalAvailable; int dir = 0; while (randomPosition > availableOnDisk[dir]) { randomPosition -= availableOnDisk[dir]; dir++; } dirNumLastAccessed = dir; returnPath = createPath(path, checkWrite); if (returnPath == null) { totalAvailable -= availableOnDisk[dir]; availableOnDisk[dir] = 0; // skip this disk numDirsSearched++; } } } else { while (numDirsSearched < numDirs && returnPath == null) { long capacity = dirDF[dirNumLastAccessed].getAvailable(); if (capacity > size) { returnPath = createPath(path, checkWrite); } dirNumLastAccessed++; dirNumLastAccessed = dirNumLastAccessed % numDirs; numDirsSearched++; } } if (returnPath != null) { return returnPath; } // no path found throw new DiskErrorException("Could not find any valid local " + "directory for " + pathStr); }
public Object call() throws Exception { _barrier.await(); // barrier, to force racing start for (long j = 0; j < _count; j++) _map.put( j + _offset, new TestKey(_rand.nextLong(), _rand.nextInt(), (short) _rand.nextInt(Short.MAX_VALUE))); return null; }
private static String randString(int len) { Random r = new Random(); StringBuilder ret = new StringBuilder(len); while (len-- > 0) { ret.append((char) (r.nextInt(26) + 'A')); } return ret.toString(); }
public static void shuffleArray(long[] a) { int n = a.length; Random random = new Random(); random.nextInt(); for (int i = 0; i < n; i++) { int change = i + random.nextInt(n - i); swap(a, i, change); } }
public static String createRandomHexNumber(int length) { Random random = new Random(System.currentTimeMillis()); char[] result = new char[length]; for (int i = 0; i < length; i++) { int r = random.nextInt(16); result[i] = Integer.toHexString(r).charAt(0); } return new String(result); }
static void genNo(int cnt, int value) throws IOException { ArrayList<Integer> ch = new ArrayList<Integer>(); for (int i = 0; i < cnt - 1; i++) ch.add(rand.nextInt(value) + 1); ch.add(ch.get(rand.nextInt(cnt - 1))); Collections.sort(ch); crypto(ch); print(); }
static void genRandom3(int cnt, int len) throws IOException { for (int i = 0; i < cnt; i++) { String t = ""; int sz = 1 + rand.nextInt(len); for (int j = 0; j < sz; j++) t += (char) ('a' + rand.nextInt(10)); data.add(t); } print(); }
private int getRand(int min, int max) { Date now = new Date(); long seed = now.getTime(); Random randomizer = new Random(seed); int n = max - min + 1; int i = randomizer.nextInt(n); if (i < 0) i = -i; return min + i; }
public void npcDied(Player p, int npcID, int abSX, int abSY) { Random rand = new Random(); try { BufferedReader in = new BufferedReader(new FileReader("./data/npcs/npcdrops.cfg")); String input; int on = 0; String[] splitEQL; String[] splitCOM; String[] splitDSH; String[] splitCLN; String[] splitSCL; while ((input = in.readLine()) != null) { splitEQL = null; splitEQL = null; splitDSH = null; splitCLN = null; splitSCL = null; if (!input.startsWith("/") && input.contains("=") && input.contains(",") && input.contains("-") && input.contains(":")) { try { splitEQL = input.split("="); if (Integer.parseInt(splitEQL[0]) == npcID) { splitSCL = splitEQL[1].split(";"); int Wealth = 0; for (int i = Wealth; i < splitSCL.length; i++) { splitCOM = splitSCL[i].split(","); splitDSH = splitCOM[1].split("-"); splitCLN = splitCOM[2].split(":"); int item = Integer.parseInt(splitCOM[0]); int min = Integer.parseInt(splitDSH[0]); int max = Integer.parseInt(splitDSH[1]); int chance = Integer.parseInt(splitCLN[0]); int outOf = Integer.parseInt(splitCLN[1]); int amount = rand.nextInt((max - min) + 1) + min; int ifDrop = rand.nextInt(outOf) + 1; if (ifDrop <= chance && npccanloot == true) { Engine.items.createGroundItem(item, amount, abSX, abSY, heightLevel, p.username); npccanloot = false; } } } } catch (Exception e) { System.out.println("Exception dropping item:\n" + e); } ++on; } } in.close(); } catch (IOException e) { System.out.println(e); } }
private int getRandomGame(int num) { int ranGame; Random randomNum = new Random(); ranGame = randomNum.nextInt(num) + 1; while (!gameRecord.containsKey(ranGame)) { ranGame = randomNum.nextInt(num) + 1; } return ranGame; }
public static void main(String[] args) throws Exception { String graphName = args[0]; int nShards = Integer.parseInt(args[1]); CircleOfTrustSalsa csalsa = new CircleOfTrustSalsa(new VertexQuery(graphName, nShards), 10000); VertexIdTranslate vertexTrans = VertexIdTranslate.fromFile( new File(ChiFilenames.getVertexTranslateDefFile(graphName, nShards))); BufferedReader cmdIn = new BufferedReader(new InputStreamReader(System.in)); while (true) { System.out.print("Enter vertex id to query >> :: "); String ln = cmdIn.readLine(); int vertex = Integer.parseInt(ln); // Circle of trust is just the vertex's followers for now HashSet<Integer> circle = csalsa.queryService.queryOutNeighbors(vertexTrans.forward(vertex)); int maxCircleSize = 300; // max 500 if (circle.size() > maxCircleSize) { int[] all = new int[circle.size()]; int i = 0; for (Integer v : circle) all[i++] = v; HashSet<Integer> filteredCircle = new HashSet<Integer>(); Random r = new Random(260379); for (i = 0; i < maxCircleSize; i++) filteredCircle.add(all[Math.abs(r.nextInt()) % all.length]); circle = filteredCircle; } csalsa.initializeGraph(circle); long t = System.currentTimeMillis(); csalsa.computeSALSA(3); logger.info("SALSA computation took " + (System.currentTimeMillis() - t) + "ms"); circle.add(vertexTrans.forward(vertex)); ArrayList<SalsaVertex> top = csalsa.topAuthorities(20, circle); int j = 1; for (SalsaVertex sv : top) { int originalId = vertexTrans.backward(sv.id); logger.info( "Top " + (j++) + " = " + originalId + " " + csalsa.namify(originalId) + " (" + sv.value + ")"); } } }
public void testNaNValues() throws ClassNotFoundException, IOException { testWriteAndRead( new ComplexClass( rand.nextInt(), rand.nextLong(), "hello", rand.nextBoolean(), Double.NaN, rand.nextFloat())); }
int selectCycle() { if (t < N) { return generator.nextInt(5); } else { if (Rtmp > alpha) { currentPath = previousPath; } else currentPath = generator.nextInt(5); } return currentPath; }