108 lines
2.5 KiB
C++
108 lines
2.5 KiB
C++
/*
|
|
VIM: let b:lcppflags="-std=c++14 -O2 -pthread -I."
|
|
VIM: let b:wcppflags="/O2 /EHsc /DWIN32"
|
|
VIM-: let b:cppflags=g:Iboost.g:Itbb
|
|
VIM-: let b:ldflags=g:Lboost.g:Ltbb
|
|
VIM-: let b:ldlibpath=g:Bboost.g:Btbb
|
|
VIM-: let b:argv=""
|
|
*/
|
|
#include <iostream>
|
|
#include <exception>
|
|
#include <chrono>
|
|
#include <vector>
|
|
#include <string>
|
|
#include <algorithm>
|
|
|
|
/*
|
|
PREFIX
|
|
|
|
Find shortest unique prefix to represent each word in the list.
|
|
|
|
Example:
|
|
|
|
Input: [zebra, dog, duck, dove]
|
|
Output: {z, dog, du, dov}
|
|
where we can see that
|
|
zebra = z
|
|
dog = dog
|
|
duck = du
|
|
dove = dov
|
|
|
|
NOTE : Assume that no word is prefix of another. In other words, the
|
|
representation is always possible.
|
|
|
|
*/
|
|
|
|
std::string get_prefix(const std::string& p1, const std::string& p2){
|
|
for ( int i = 0; i < p1.size() && i < p2.size(); ++i){
|
|
if ( p1[i] != p2[i] ){
|
|
return p1.substr(0,i+1);
|
|
}
|
|
}
|
|
return p1;
|
|
}
|
|
|
|
std::vector<std::string> prefix(const std::vector<std::string> &A) {
|
|
// Do not write main() function.
|
|
// Do not read input, instead use the arguments to the function.
|
|
// Do not print the output, instead return values as specified
|
|
// Still have a doubt. Checkout www.interviewbit.com/pages/sample_codes/ for more details
|
|
|
|
std::vector<std::string> ret(A.size());
|
|
|
|
std::vector<int> B(A.size());
|
|
for ( size_t i = 0; i < A.size(); ++i){
|
|
B[i] = i;
|
|
}
|
|
std::sort(B.begin(), B.end(), [&A](int op1, int op2){
|
|
return A[op1] < A[op2];
|
|
});
|
|
|
|
for (int i = 0; i < B.size(); ++i){
|
|
std::string p;
|
|
if ( i-1 >= 0 ) {
|
|
p = get_prefix(A[B[i]],A[B[i-1]]);
|
|
}
|
|
if ( i+1 < A.size() ){
|
|
auto _p = get_prefix(A[B[i]],A[B[i+1]]);
|
|
if ( _p.size() > p.size() ) {
|
|
p = _p;
|
|
}
|
|
}
|
|
if ( p.empty() ) {
|
|
p = A[B[i]].substr(0,1);
|
|
}
|
|
ret[B[i]] = p;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
int main ( void )
|
|
{try{
|
|
auto begin = std::chrono::high_resolution_clock::now();
|
|
|
|
auto p = prefix({"zebra", "dog", "duck", "dove"});
|
|
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
std::chrono::duration<double> seconds = end - begin;
|
|
std::cout << "Time: " << seconds.count() << std::endl;
|
|
for ( const auto& _p : p) {
|
|
std::cout << _p << std::endl;
|
|
}
|
|
return 0;
|
|
}
|
|
catch ( const std::exception& e )
|
|
{
|
|
std::cerr << std::endl
|
|
<< "std::exception(\"" << e.what() << "\")." << std::endl;
|
|
return 2;
|
|
}
|
|
catch ( ... )
|
|
{
|
|
std::cerr << std::endl
|
|
<< "unknown exception." << std::endl;
|
|
return 1;
|
|
}}
|
|
|