コード例 #1
0
TestCase * Grader07::testSpellCheck(std::string filename)
{
  Commands07 cmds07;
  std::vector<std::string> words;
  std::vector<SpellCheckCmd> commands;

  cmds07.readReads("words", words);
  cmds07.loadSpellCheckCommands(filename, commands);

  if(words.size() == 0){
    return failed("cannot read input file #1");
  }

  if(commands.size() == 0){
    return failed("cannot read input file #2");
  }

  Stopwatch watch;
  watch.start();

  ISpellCheck * checker = (ISpellCheck *) createObject("ISpellCheck");
  if(checker == NULL){
    return nullObject("ISpellCheck");
  }

  watch.pause();
  checker->loadDictionary(words);
  watch.unpause();

  for(size_t i = 0; i < commands.size(); ++i){
    SpellCheckCmd cmd = commands[i];
    std::vector<std::string> product_corrections = checker->suggestCorrections(cmd.word);
    watch.pause();
    std::sort(product_corrections.begin(), product_corrections.end());
    if(product_corrections != cmd.corrections){
      return failed("corrections mismatch");
    }
    watch.unpause();
  }

  watch.stop();
  return passed(watch.getTime());
}
コード例 #2
0
TestCase * Grader07::testStringSearch(std::string cmds_filename, std::string input_filename)
{
  std::vector<StringSearchCmd> commands;

  Commands07 cmds07;
  cmds07.loadStringSearchCommmands(cmds_filename, commands);
  std::string to_search = cmds07.readStringFile(input_filename);

  if(commands.size() == 0){
    return failed("cannot read input file #1");
  }

  if(to_search == ""){
    return failed("cannot read input file #2");
  }

  Stopwatch watch;
  watch.start();

  IStringSearch * searcher = (IStringSearch *) createObject("IStringSearch");
  if(searcher == NULL){
    return nullObject("IStringSearch");
  }

  watch.pause();
  searcher->prepareText(to_search);
  watch.unpause();

  for(size_t i = 0; i < commands.size(); ++i){
    StringSearchCmd cmd = commands[i];
    std::vector<int> product_results = searcher->search(cmd.to_find);
    if(product_results.size() != cmd.positions.size()){
      return failed("incorrect return size");
    }
    std::sort(product_results.begin(), product_results.end());
    if(product_results != cmd.positions){
      return failed("at least one incorrect return index");
    }
  }

  watch.stop();
  return passed(watch.getTime());
}
コード例 #3
0
TestCase * Grader02::testWorkload4(int len, int order, int merge_count,
	int merge_len){

	std::vector<int> input;
	std::vector<int> sorted;
	createVector(input, sorted, order, len, false);

	Stopwatch watch;
	watch.start();

	IPriorityQueue * queue = (IPriorityQueue *)createObject("IPriorityQueue4");
	if (queue == NULL){
		return nullObject("IPriorityQueue4");
	}

	watch.pause();
	GoldPriorityQueue gold_queue(sorted);

	for (size_t i = 0; i < merge_len; ++i){
		int key = input[i];
		std::string value = randomValue();
		gold_queue.push_back(key, value);

		watch.unpause();
		IKeyValue * key_value = (IKeyValue *)createObject("IKeyValue4");
		if (key_value == NULL){
			return nullObject("IKeyValue4");
		}

		key_value->setKey(key);
		key_value->setValue(value);

		queue->enqueue(key_value);

		int size = queue->size();
		if (size != gold_queue.size()){
			return failed("after enqueue, size is incorrect");
		}

		int user_key = queue->lowestKey();
		IVectorString * user_values = queue->lowestValues();
		gold_queue.iterate();
		int gold_key = gold_queue.lowestKey();
		std::vector<std::string> values = gold_queue.getValues(gold_key);
		watch.pause();

		if (gold_key != user_key){
			return failed("after enqueue, lowest key is incorrect");
		}

		if (valuesEqual(user_values, values) == false){
			return failed("after enqueue, values incorrect");
		}
	}

	for (int i = 1; i < merge_count; ++i){
		watch.unpause();
		IPriorityQueue * queue2 = (IPriorityQueue *)createObject("IPriorityQueue4");
		if (queue == NULL){
			return nullObject("IPriorityQueue4");
		}

		watch.pause();

		for (int j = (i * merge_len); j < ((i + 1) * merge_len); ++j){
			int key = input[j];
			std::string value = randomValue();
			gold_queue.push_back(key, value);

			watch.unpause();
			IKeyValue * key_value = (IKeyValue *)createObject("IKeyValue4");
			if (key_value == NULL){
				return nullObject("IKeyValue4");
			}

			key_value->setKey(key);
			key_value->setValue(value);

			queue2->enqueue(key_value);
			watch.pause();
		}

		watch.unpause();
		queue->merge(queue2);
		watch.pause();

		gold_queue.iterate();

		watch.unpause();
		int user_key = queue->lowestKey();
		IVectorString * user_values = queue->lowestValues();
		watch.pause();

		int gold_key = gold_queue.lowestKey();
		std::vector<std::string> values = gold_queue.getValues(gold_key);

		if (gold_key != user_key){
			return failed("during dequeue, lowest key is incorrect");
		}

		if (valuesEqual(user_values, values) == false){
			return failed("during dequeue, values incorrect");
		}
	}

	return passed(watch.getTime());
}
コード例 #4
0
TestCase * Grader02::testWorkload1(int len, int order){

	std::vector<int> input;
	std::vector<int> sorted;
	createVector(input, sorted, order, len, true);

	Stopwatch watch;
	watch.start();

	IPriorityQueue * queue = (IPriorityQueue *)createObject("IPriorityQueue1");
	if (queue == NULL){
		return nullObject("IPriorityQueue1");
	}

	watch.pause();
	GoldPriorityQueue gold_queue(sorted);
	for (size_t i = 0; i < input.size(); ++i){
		int key = input[i];
		std::string value = randomValue();
		gold_queue.push_back(key, value);

		watch.unpause();
		IKeyValue * key_value = (IKeyValue *)createObject("IKeyValue1");
		if (key_value == NULL){
			return nullObject("IKeyValue1");
		}

		key_value->setKey(key);
		key_value->setValue(value);

		queue->enqueue(key_value);

		int size = queue->size();
		if (size != gold_queue.size()){
			return failed("after enqueue, size is incorrect");
		}

		int user_key = queue->lowestKey();
		IVectorString * user_values = queue->lowestValues();
		gold_queue.iterate();
		int gold_key = gold_queue.lowestKey();
		std::vector<std::string> values = gold_queue.getValues(gold_key);
		watch.pause();

		if (gold_key != user_key){
			return failed("after enqueue, lowest key is incorrect");
		}

		if (valuesEqual(user_values, values) == false){
			return failed("after enqueue, values incorrect");
		}

		bool check_sort = true;
		if (len != 10 && i % 100 != 0){
			check_sort = false;
		}

		if (check_sort){
			watch.unpause();
			IVectorKeyValue * user_sorted = queue->returnSorted();
			watch.pause();
			if (sortedEqual(user_sorted, gold_queue.returnSorted()) == false){
				return failed("after enqueue, sorted is not equal");
			}
		}
	}

	gold_queue.iterate();
	int count = 0;
	while (gold_queue.hasNext()){
		watch.unpause();
		int user_key = queue->lowestKey();
		IVectorString * user_values = queue->lowestValues();
		watch.pause();

		int gold_key = gold_queue.lowestKey();
		std::vector<std::string> values = gold_queue.getValues(gold_key);

		if (gold_key != user_key){
			return failed("during dequeue, lowest key is incorrect");
		}

		if (valuesEqual(user_values, values) == false){
			return failed("during dequeue, values incorrect");
		}

		watch.unpause();
		int size = queue->size();
		watch.pause();
		if (size != gold_queue.size()){
			return failed("during dequeue, size is incorrect");
		}

		bool check_sort = true;
		if (len != 10 && count % 100 != 0){
			check_sort = false;
		}

		if (check_sort){
			IVectorKeyValue * user_sorted = queue->returnSorted();
			std::vector<std::pair<int, std::string> > gold_sorted = gold_queue.returnSorted();
			if (sortedEqual(user_sorted, gold_sorted) == false){
				return failed("during dequeue, sorted is not equal");
			}
		}

		watch.unpause();
		queue->dequeue();
		watch.pause();
		gold_queue.dequeue();
		++count;
	}

	return passed(watch.getTime());
}