如何解决仅使用通过索引获得单词的方法在未知大小的字典中查找单词
|| 几天前，我在某大公司接受了面试，名字不是必需的：)，面试官让我找到下一个任务的解决方案： 预定义： 有未指定大小的单词字典，我们只知道字典中的所有单词都已排序（例如，按字母排序）。而且我们只有一种方法String getWord(int index) throws IndexOutOfBoundsException
public boolean isWordInTheDictionary(String word)
public class Dictionary {
private static final int BIGGEST_TOP_MASK = 0xF00000;
private static final int LESS_TOP_MASK = 0x0F0000;
private static final int FULL_MASK = 0xFFFFFF;
private String[] data;
private static final int STEP = 100; // for real test step should be Integer.MAX_VALUE
private int shiftIndex = -1;
private static final int LESS_MASK = 0x0000FF;
private static final int BIG_MASK = 0x00FF00;
public Dictionary() {
data = getData();
}
String getWord(int index) throws IndexOutOfBoundsException {
return data[index];
}
public String[] getData() {
return new String[]{\"a\",\"aaaa\",\"asss\",\"az\",\"b\",\"c\",\"d\",\"e\",\"f\",\"g\",\"h\",\"i\",\"j\",\"k\",\"l\",\"m\",\"n\",\"o\",\"p\",\"q\",\"r\",\"s\",\"t\",\"test\",\"u\",\"v\",\"w\",\"x\",\"y\",\"z\"};
}
public boolean isWordInTheDictionary(String word) {
boolean isFound = false;
int constantIndex = STEP; // predefined step
int flag = 0;
int i = 0;
while (true) {
i++;
if (flag == FULL_MASK) {
System.out.println(\"Word is not found ... Steps \" + i);
break;
}
try {
String data = getWord(constantIndex);
if (null != data) {
int compareResult = word.compareTo(data);
if (compareResult > 0) {
if ((flag & LESS_MASK) == LESS_MASK) {
constantIndex = prepareIndex(false,constantIndex);
if (shiftIndex == 1)
flag |= BIGGEST_TOP_MASK;
} else {
constantIndex = constantIndex * 2;
}
flag |= BIG_MASK;
} else if (compareResult < 0) {
if ((flag & BIG_MASK) == BIG_MASK) {
constantIndex = prepareIndex(true,constantIndex);
if (shiftIndex == 1)
flag |= LESS_TOP_MASK;
} else {
constantIndex = constantIndex / 2;
}
flag |= LESS_MASK;
} else {
// YES!!! We found word.
isFound = true;
System.out.println(\"Steps \" + i);
break;
}
}
} catch (IndexOutOfBoundsException e) {
if (flag > 0) {
constantIndex = prepareIndex(true,constantIndex);
flag |= LESS_MASK;
} else constantIndex = constantIndex / 2;
}
}
return isFound;
}
private int prepareIndex(boolean isBiggest,int constantIndex) {
shiftIndex = (int) Math.ceil(getIndex(shiftIndex == -1 ? constantIndex : shiftIndex));
if (isBiggest)
constantIndex = constantIndex - shiftIndex;
else
constantIndex = constantIndex + shiftIndex;
return constantIndex;
}
private double getIndex(double constantIndex) {
if (constantIndex <= 1)
return 1;
return constantIndex / 2;
}
}
解决方法
听起来他们真正想让您考虑的部分是如何处理您不知道字典大小的事实。我认为他们假设您可以对他们进行二进制搜索。因此，真正的问题是如何随着搜索的进行来操纵搜索范围。
一旦您在字典中找到了一个大于搜索目标（或超出范围）的值，其余的看起来就像是标准的二进制搜索。困难的部分是当目标值大于您查找的字典值时，如何最佳地扩展范围。看起来您正在扩展1.5倍。巨大的字典和小的固定初始步骤（如您所拥有的（100））可能确实有问题。想想如果有5000万个单词，如果您要搜索“斑马”，您的算法将向上扩展范围的次数必须达到多少次。
这是一个主意：通过假设每个单词的第一个字母均匀分布在字母表中的各个字母来利用集合的有序性质（这永远都是不对的，但在不了解更多单词集合的情况下）这可能是您所能做的最好的事情。然后，根据您希望字典单词到末尾的距离，对范围扩展量进行加权。
因此，如果您迈出了第一步，并在该索引处查找了字典单词，并且它是\'aardvark \'，那么与下一步相比，如果您将其范围扩大到\“ walrus”，则您的范围会更多。 O（log n），但对于大多数单词集合而言可能更好。
, 这是使用
Collections.binarySearch
\'\\uffff\'
public static class ListProxy extends AbstractList<String> implements RandomAccess
{
@Override public String get( int index )
{
try {
return getWord( index );
} catch( IndexOutOfBoundsException ex ) {
return \"\\uffff\";
}
}
@Override public int size()
{
return Integer.MAX_VALUE;
}
}
public static boolean isWordInTheDictionary( String word )
{
return Collections.binarySearch( new ListProxy(),word ) >= 0;
}
RandomAccess
public static class ListProxy extends AbstractList<String> implements RandomAccess
{
private int size = Integer.MAX_VALUE;
@Override public String get( int index )
{
try {
if( index < size )
return getWord( index );
} catch( IndexOutOfBoundsException ex ) {
size = index;
}
return \"\\uffff\";
}
@Override public int size()
{
return size;
}
}
private static ListProxy listProxy = new ListProxy();
public static boolean isWordInTheDictionary( String word )
{
return Collections.binarySearch( listProxy,word ) >= 0;
}
#!/usr/bin/perl
$t=0;
$cur=1;
$under=0;
$EOL=int(rand(1000000))+1;
$TARGET=int(rand(1000000))+1;
if ($TARGET>$EOL)
{
$x=$EOL;
$EOL=$TARGET;
$TARGET=$x;
}
print \"Looking for $TARGET with EOL $EOL\\n\";
sub testWord($)
{
my($a)=@_;
++$t;
return 0 if ($a eq $TARGET);
return -2 if ($a > $EOL);
return 1 if ($a > $TARGET);
return -1;
}
while ($r = testWord($cur))
{
print \"Tested $cur,got $r\\n\";
if ($r == 1) { $over=$cur; }
if ($r == -1) { $under=$cur; }
if ($r == -2) { $over = $cur; }
if ($over)
{
$cur = int(($over-$under)/2)+$under;
$cur++ if ($cur <= $under);
$cur-- if ($cur >= $over);
}
else
{
$cur *= 2;
}
}
print \"Found $TARGET at $r in $t tests\\n\";
boolean isWordInTheDictionary(String word){
if (word == null){
return false;
}
// estimate the length of the dictionary array
long len=2;
String temp= getWord(len);
while(true){
len = len * 2;
try{
temp = getWord(len);
}catch(IndexOutOfBoundsException e){
// found upped bound break from loop
break;
}
}
// Do a modified binary search using the estimated length
long beg = 0 ;
long end = len;
String tempWrd;
while(true){
System.out.println(String.format(\"beg: %s,end=%s,(beg+end)/2=%s \",beg,end,(beg+end)/2));
if(end - beg <= 1){
return false;
}
long idx = (beg+end)/2;
tempWrd = getWord(idx);
if(tempWrd == null){
end=idx;
continue;
}
if ( word.compareTo(tempWrd) > 0){
beg = idx;
}
else if(word.compareTo(tempWrd) < 0){
end= idx;
}else{
// found the word..
System.out.println(String.format(\"getword at index: %s,=%s\",idx,getWord(idx)));
return true;
}
}
}
public WordFindingResult FindWord(string word)
{
var callsCount = 0;
var lowerLimit = new WordFindingLimit(0,null);
var upperLimit = new WordFindingLimit(int.MaxValue,null);
var wordToFind = new Word(word);
var wordIndex = _initialIndex;
while (callsCount <= _maximumCallsCount)
{
if (CouldNotFindWord(lowerLimit,upperLimit))
return new WordFindingResult(callsCount,-1,string.Empty,WordFindingResult.ErrorCodes.NOT_FOUND);
var wordFound = RetrieveWordAt(wordIndex);
callsCount++;
if (wordToFind.Equals(wordFound))
return new WordFindingResult(callsCount,wordIndex,wordFound.OriginalWordString);
else if (IsIndexTooHigh(wordToFind,wordFound))
{
upperLimit = new WordFindingLimit(wordIndex,wordFound);
wordIndex = IndexConsideringTooHighPreviousResult(lowerLimit,wordIndex);
}
else
{
lowerLimit = new WordFindingLimit(wordIndex,wordFound);
wordIndex = IndexConsideringTooLowPreviousResult(lowerLimit,upperLimit,wordToFind);
}
}
return new WordFindingResult(callsCount,WordFindingResult.ErrorCodes.CALLS_LIMIT_EXCEEDED);
}
private int IndexConsideringTooHighPreviousResult(WordFindingLimit maxLowerLimit,int current)
{
return BinarySearch(maxLowerLimit.Index,current);
}
private int IndexConsideringTooLowPreviousResult(WordFindingLimit maxLowerLimit,WordFindingLimit minUpperLimit,Word target)
{
if (AreLowerAndUpperLimitsDefined(maxLowerLimit,minUpperLimit))
return BinarySearch(maxLowerLimit.Index,minUpperLimit.Index);
var scoreByIndexPosition = maxLowerLimit.Index / maxLowerLimit.Word.Score;
var indexOfTargetBasedInScore = (int)(target.Score * scoreByIndexPosition);
return indexOfTargetBasedInScore;
}
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。