## Would a two word domain name with a shared letter between the words be treated the same for SEO as the fuller name?

I found a domain name (2 words) that is not available. Then I found almost the same domain name with a slight difference, the last letter of the first word is the same of the first letter of the second word.

Ex : jamessecret.com (not available)      jamesecret.com (available) 

In terms of SEO, is it seen as the same to Google? Would search engines interpret them the same?

## Short Version:

### How can we construct such a trie which maps abbreviations of names-of-the-month to full-month (we map the abbreviation "mar" to "march")?

• The set of all abbreviations is formed by:
• keeping the first letter of the month name. (all abbreviations of "january" begin with "j")
• deleting 1 or more characters ("jan" deletes "uary" from "january")

### The Looonnnnggg Version:

How can we construct such a trie?
What algorithm will build the appropriate trie from the container of verbose strings.

Consider the English names for months of the year:

• January
• February
• March
• April
• [… truncated …]
• October
• November
• December

We find it useful say that the English names for months of the year are "verbose" strings.
For any "verbose" string $$v$$, and any string $$a$$ we say that $$a$$ is an "abbreviation" of $$v$$ if and only if all of the following conditions are met:

• $$a$$ non-empty. $$|a| \geq 1$$
• $$a$$ can formed by deleting 1 or more characters from "verbose" string $$v$$
• $$a(1) = v(1)$$. Assume that string indexing begins at $$1$$, and not $$0$$.

For example, "jan" is an abbreviation of "january."

Suppose you want to write an algorithm which:

• accepts a list of verbose strings as inputs.
• the algorithm outputs a "trie" data-structure (information retrieval tree) $$T$$ such that:
• The trie $$T$$ accepts any ASCII string as input.
• An output (leaf node) of the trie should be set of strings $$S$$ such that:
• every string in $$S$$ is a verbose string
• the string fed as input into trie $$T$$ is an abbreviation of every verbose string in container $$S$$

Some examples of input to the trie and output of the trie are shown below:

• Example 1

• Input: "Ma"
• Output: $$\{$$"March", "May"$$\}$$
• Example 2

• Input: "Mar"
• Output: $$\{$$"March"$$\}$$
• Example 3

• Input: "Decuary"
• Output: $$\{$$" "$$\}$$ ….. the empty-set

The output from the trie should be one of:

• the empty set
• a set of one item
• a set of two or more items

For months of the year, we might write javascript so that an end-user can type in any half-way reasonable date-format, instead getting an error message when they put slashes instead of dashes, etc….

If you do not like the months of the year application, a different use-case would be to write write your own Linux Shell (similar to BASH). Maybe any half-way reasonable abbreviation of "make directory" will map to "mkdir" In that case, we could have many-to-one mapping from high-level shell-commands to low-level Linux commands.

### The question is:

How can we construct such a trie?
What algorithm will build the appropriate trie from the container of verbose strings.

Also, can we avoid brute-force generating a list of all aberrations before-hand? The set of all strings form-able by deleting 1 or more characters from the verbose strings is quite large. We would like to avoid combinatorial explosion, if we can.

The programming language (Java, python, C+ + ) does not matter for answering this question.

Posted on Categories proxies

## Number of words of length n for special language

Let $$\Sigma$$ be an alphabet and let $$L$$ be a language over it with the following properties:

1. if $$w\in L$$ then there exists $$v\in \Sigma^*$$ such that $$wv \in L$$ and for every $$s\in \Sigma$$ the word $$wvs$$ does not lie in $$L$$
2. $$wv\in L$$ then $$vw \in L$$
3. It is prefix-closed, i.e. prefix of any word is still in the language.

Note that by the definition, it is not cyclic language. I’m trying to compute its growth function, by that I mean $$\gamma_n:= |\{w\in L \mid |w| = n\}|$$. I know about my specific case that it is not regular and my hypothesis is that function $$\Gamma(x) = \sum_{n=1}^\infty \gamma_nx^n$$ is not rational. However, I couldn’t find any information about these functions for non-regular languages. Maybe, there’s a formula that connects entropy of language, i.e. $$e(L):= \limsup\limits_{n\to\infty} \frac{\log\gamma_n}{n}$$ and the $$\Gamma$$ function. Or for such a language there’s a way to describe its growth throughout the growth of the language $$\operatorname{End}(L) = \{ w\in L \mid \forall s\in \Sigma \,ws \text{ is not in } L \}$$.

## Is my recursive algorithm for Equivalent Words correct?

Here is my problem.

Problem Given two words and a dictionary, find out whether the words are equivalent.

Input: The dictionary, D (a set of words), and two words v and w from the dictionary.

Output: A transformation of v into w by substitutions such that all intermediate words belong to D. If no transformation is possible, output “v and w are not equivalent.”

I need to write both recursive and dynamic programming algorithm. As for recursion, I came up with this algorithm. Is it correct?

 EquivalentWordsProblem(v, w, D)  1.m <- len (v)  2.n <-  len (w)  3.substitutions = [] #array to save substitutions   4.if m != n:  5.  return "v and w are not equivalent"  6.else  7.for i <- m to 1 <-1 do  8.  for j <- n to j <- 1 do  9.    if v[i] != w[j]:  10.           substituted_word <- v[1…i-1]+v[j] #we substitute v[i] for w[j]  11.              if substituted_word in D:  12.                substitutions.append(substituted_word)  13.                   return EquivalentWordsProblem(v[1…m-i], w, D) #recur on the string of length m - i  14.   else:          return EquivalentWordsProblem(v[1…m-1], w, D) #recur on the string decreasing its length by 1  15.if len(substitutions) != 0:  16.  return substitutions   17.else  18.   return (“v and w are not equivalent”)  
Posted on Categories proxies