Returns a list of words.

@param count      the number of words to get
@param startLorem whether to start with standard Lorem Ipsum text
@return a list of lorem ipsum words
555010
public static List<String> getWords(int count, boolean startLorem) {
        LinkedList<String> wordList = new LinkedList<String>();

        if (startLorem) {
            if (count > COMMON_WORDS.length) {
                wordList.addAll(Arrays.asList(COMMON_WORDS));

            } else {
                // add first "count" words
                for (int i = 0; i < count; i++) {
                    wordList.add(COMMON_WORDS[i]);
                }
            }
        }

        // add remaining words (random)
        for (int i = wordList.size(); i < count; i++) {
            wordList.add(QuickUtils.math.getRandomPosition(DICTIONARY));
        }

        return wordList;
    }
1135637
public List<int[]> commonPrefixSearch(String query, int start)
    {
        List<int[]> ret = new ArrayList<int[]>(5);
        if ((query == null) || (start >= query.length()))
        {
            return ret;
        }
        int curState = 1;
        for (int i = start; i < query.length(); i++)
        {
            int[] res = transferValues(curState, query.charAt(i));
            if (res[0] == -1)
            {
                break;
            }
            curState = res[0];
            if (res[1] != -1)
            {
                ret.add(new int[]{i - start + 1, res[1]});
            }
        }
        return ret;
    }
1364268
@Override
    public Pair<List<String>, AtomicLong> call(List<String> lstOfWords) throws Exception {
        List<String> stops = stopWords.getValue();
        Counter<String> counter = new Counter<>();

        for (String w : lstOfWords) {
            if (w.isEmpty())
                continue;

            if (!stops.isEmpty()) {
                if (stops.contains(w)) {
                    counter.incrementCount("STOP", 1.0f);
                } else {
                    counter.incrementCount(w, 1.0f);
                }
            } else {
                counter.incrementCount(w, 1.0f);
            }
        }
        wordFreqAcc.add(counter);
        AtomicLong lstOfWordsSize = new AtomicLong(lstOfWords.size());
        return new Pair<>(lstOfWords, lstOfWordsSize);
    }
846248
def get_word_counts(word)
      # fetch all (class,count) pairs for a given word
      row = @cassandra.get(:classes, word.to_s)
      return row.to_hash if row.empty?
      row.inject({}){|counts, col| counts[col.first.to_sym] = [col.last.to_f,0].max; counts}
    end
717760
public static long count(nitro_service service) throws Exception
	{
		sms_server obj = new sms_server();
		options option = new options();
		option.set_count(true);
		sms_server[] response = (sms_server[])obj.get_resources(service, option);
		if (response != null && response.length > 0)
			return response[0].__count;
		return 0;
	}
497587
public static <T> String extractNgram(List<T> list, int start, int end) {
    if (start < 0 || end > list.size() || start >= end) return null;
    final StringBuilder sb = new StringBuilder();
    // TODO: iterator
    for (int i = start; i < end; i++) {
      T o = list.get(i);
      if (sb.length() != 0) sb.append(" ");
      sb.append((o instanceof HasWord) ? ((HasWord) o).word() : o.toString());
    }
    return sb.toString();
  }
1143945
public Collection<HotlistTag> getHotList(String period, int count) throws FlickrException {

        Map<String, Object> parameters = new HashMap<String, Object>();
        parameters.put("method", METHOD_GET_HOT_LIST);

        parameters.put("period", period);
        parameters.put("count", "" + count);

        Response response = transportAPI.get(transportAPI.getPath(), parameters, apiKey, sharedSecret);
        if (response.isError()) {
            throw new FlickrException(response.getErrorCode(), response.getErrorMessage());
        }

        Element tagsElement = response.getPayload();

        List<HotlistTag> tags = new ArrayList<HotlistTag>();
        NodeList tagElements = tagsElement.getElementsByTagName("tag");
        for (int i = 0; i < tagElements.getLength(); i++) {
            Element tagElement = (Element) tagElements.item(i);
            HotlistTag tag = new HotlistTag();
            tag.setScore(tagElement.getAttribute("score"));
            tag.setValue(((Text) tagElement.getFirstChild()).getData());
            tags.add(tag);
        }
        return tags;
    }
1107991
public static List<Word> getWords(String text) {
        List<Word> result = new ArrayList<>();
        List<Word> words = WordParser.parse(text);
        for (Word word : words) {
            result.add(word);
        }
        return result;
    }
264855
public SortingParams limit(final int start, final int count) {
    params.add(LIMIT.raw);
    params.add(Protocol.toByteArray(start));
    params.add(Protocol.toByteArray(count));
    return this;
  }
168083
public String peek(int count)
	{
		return str.substring(cursor, cursor+Math.min(count, str.length()-cursor));
	}
1296179
public static List<String> getTopSentenceList(String document, int size, String sentence_separator)
    {
        List<String> sentenceList = splitSentence(document, sentence_separator);
        List<List<String>> docs = convertSentenceListToDocument(sentenceList);
        TextRankSentence textRank = new TextRankSentence(docs);
        int[] topSentence = textRank.getTopSentence(size);
        List<String> resultList = new LinkedList<String>();
        for (int i : topSentence)
        {
            resultList.add(sentenceList.get(i));
        }
        return resultList;
    }
989154
public UserListResult getAdminListByAppkey(int start, int count)
    		throws APIConnectionException, APIRequestException {
    	return _userClient.getAdminListByAppkey(start, count);
    }
565846
public function groupGetlist($begin=0,$count=1000){
        $params=array(
            'begin'=>$begin,
            'count'=>$count,
        );
        $rst = $this->_request->post($this->_url . 'group/getlist', $params);
        return $this->_client->rst($rst);
    }
74119
@Override
    public List<String> getKeywords(List<Term> termList, int size)
    {
        clear();
        add(termList);
        Collection<TermFrequency> topN = top(size);
        List<String> r = new ArrayList<String>(topN.size());
        for (TermFrequency termFrequency : topN)
        {
            r.add(termFrequency.getTerm());
        }
        return r;
    }
1208873
public List<String> getWords() {
        List<String> result = new ArrayList<>();
        List<Word> words = WordParser.parse(question.replace("?", "").replace("？", ""));
        for (Word word : words) {
            result.add(word.getText());
        }
        return result;
    }
1157489
def find_next_word_beginning(self, count=1, WORD=False):
        
        if count < 0:
            return self.find_previous_word_beginning(count=-count, WORD=WORD)

        regex = _FIND_BIG_WORD_RE if WORD else _FIND_WORD_RE
        iterator = regex.finditer(self.text_after_cursor)

        try:
            for i, match in enumerate(iterator):
                # Take first match, unless it's the word on which we're right now.
                if i == 0 and match.start(1) == 0:
                    count += 1

                if i + 1 == count:
                    return match.start(1)
        except StopIteration:
            pass
602742
List<String> wordList() {
        List<String> words = new ArrayList<>();

        if (userName != null) {
            words.add(userName);
        }

        if (name != null) {
            if (name.givenName != null) {
                words.add(name.givenName);
            }
            if (name.familyName != null) {
                words.add(name.familyName);
            }
            if (nickName != null) {
                words.add(nickName);
            }
        }

        if (emails != null) {
            for (Email email : emails) {
                words.add(email.getValue());
            }
        }

        return words;
    }