## How to store a set of long character strings to find a long character string key

I have a set of several thousand strings of maximum length 1024 (containing all visible ASCII characters plus space) that I need to store to make it quicker to find an exact match for a key. What is the best algorithm for storing the set and looking for a match?

## email: how do you extract specific strings from an attachment in a SharePoint list?

I want to extract certain parts of the email content and put the results in the list item fields.

I want to add this to a flow that I have already created that:

1. Forward an email from a shared mailbox to a SharePoint
2. Then a list item is created in that list
3. The body of the email is converted from HTML to text.
4. The result of that conversion enters a list item field
5. The field content of that list item is used to create a text file and is attached to the list item.

For example, a string I'm interested in extracting:

• will always be a line
• will always be the last line
• I want to put that line in a text field in my list item

Is there a way to do this?

## Combinatorial problem in non-collinear strings in the \$ n times n \$ box

exist $$n times n$$ points. How many strings exist at its vertices, where there are not three collinear points and each point is used at most once.
I have drawn examples below (red is fine but green is not).

## C # How to remove characters, numbers and blanks from an array of strings?

Remove characters, numbers, and blanks from
current string [] = "a] 773 b"; "e] 1597 t"; "z] 0 c"
so that the result is string [] result = "a, b"; "e, t"; "z, c"?
note: deleted items must be replaced with ",".

## strings – Uppercase and lowercase function in C

I have written the following function in C, which will take as input a character array (decayed to a char *, of course), and will mutate the string into an uppercase string in the title in the form "this is a string" -> "This is a chain."

``````void title_case(char str())
{
assert(str);
size_t i;
str(0) = toupper((int) str(0));
if(strlen(str) == 1) return;
for(i = 1; i < strlen(str); ++i)
{
str(i) = tolower((int)str(i));
if(str(i -1) == ' ')
{
str(i) = toupper((int)str(i));
}
}
return;
}
``````

Please provide any comments you consider appropriate. Is there a more concise way to do this? Is the notation in parentheses the clearest form?

Driver:

``````#include
#include
#include
#include

void title_case(char str());
int main(void)
{
char sentence() = "this is a SeNTeNce.";
title_case(sentence);
printf("%sn", sentence);
return 0;
}
``````

## How to compare two strings?

In python, you can do this:

``````"ab">"ac"
``````

returns `False`.

In Mathematica, it doesn't evaluate.

But why? These are literal strings, not symbols.

## C program that compares software version strings

Instead of spelling out each element of the array,

``````char ver_string() = {'5','.','2','5','.','5','.','0',''};
``````

just use a string literal. Is the same:

``````char ver_string() = "5.25.5.0";
``````

Instead of using `assert` in its functions just trust the user to pass a non-null pointer.

Should I print to stderr only in the (main) controller program and leave all of that out of the main "library" code?

Yes, exactly. You can return error codes and configure `errno` to be more specific.

Second, I have a `enum` definition for `FAIL` but I never actually use it because when I wrote the change clause I thought it might be a better idea to just default the error instead of explicitly selecting it.

It's okay. Anything other than a valid entry is an invalid entry.

Does not return a value of `version_parse` although it looks like he even inserted a new line where he was supposed to go.

Instead of using `LEFT` Y `RIGHT`, I would use `GREATER` Y `LESS`. Those names convey more meaning to me.

Functions that don't take values ​​usually have an unnamed name `void` parameter. I suggest doing that with `main`, because it could be undefined behavior if not:

``````int main(void)
{
``````

(I also fixed the format to make it more consistent.)

All these `(unsigned int)` molds are not necessary:

``````pVer->major = (unsigned int) atoi(token);
token = strtok(NULL, delim);
pVer->minor = (unsigned int) atoi(token);
token = strtok(NULL, delim);
pVer->build = (unsigned int) atoi(token);
token = strtok(NULL, delim);
pVer->revision = (unsigned int) atoi(token);
``````

In `validate_version_string`, `tmp` Y `copy` are unnecessary just use `str` Y `*str`, like:

``````for(; *str != ''; ++str)
{
if(*str == '.') ++count;
if((*str > '9' || *str < '0') && *str != '.') return false;
}
``````

You may think that delete `tmp` it's bad for performance, but it's not; at any non-zero optimization level, these are equivalent.

The main thing I would like to say is:

Don't reinvent the wheel.

if you have `strverscmp` available (GNU libc and others), and your code doesn't have to be portable, why not use it?

## vb.net – Conversion of strings to type "long" is invalid

In a program I'm doing, a user-determined directory is needed to export a .bat.

`````` System.InvalidCastException: A conversão da cadeia de caracteres 'C:UsersDesktop' no tipo 'Long' não é válida. ---> System.FormatException: A cadeia de caracteres de entrada não estava em um formato correto.
em Microsoft.VisualBasic.CompilerServices.Conversions.ParseDecimal(String Value, NumberFormatInfo NumberFormat)
em Microsoft.VisualBasic.CompilerServices.Conversions.ToLong(String Value)
--- Fim do rastreamento de pilha de exceções internas ---
em Microsoft.VisualBasic.CompilerServices.Conversions.ToLong(String Value)
em System.Windows.Forms.Form.OnCreateControl()
em System.Windows.Forms.Control.CreateControl(Boolean fIgnoreVisible)
em System.Windows.Forms.Control.CreateControl()
em System.Windows.Forms.Control.WmShowWindow(Message& m)
em System.Windows.Forms.Control.WndProc(Message& m)
em System.Windows.Forms.ScrollableControl.WndProc(Message& m)
em System.Windows.Forms.Form.WmShowWindow(Message& m)
em System.Windows.Forms.Form.WndProc(Message& m)
em System.Windows.Forms.Control.ControlNativeWindow.OnMessage(Message& m)
em System.Windows.Forms.Control.ControlNativeWindow.WndProc(Message& m)
em System.Windows.Forms.NativeWindow.Callback(IntPtr hWnd, Int32 msg, IntPtr wparam, IntPtr lparam)
``````

The line that causes all commands to be exported to .bat is this

`````` IO.File.WriteAllText(path.TextBox1.Text  "fastt.bat", sb.ToString())
``````

## Search multiple individual text strings, using "text contains" in Google Sheets

Go to Filter by condition Custom formula and insert the following:

``````=MATCH(A2, {"amazon", "amz", "azamon"}, 0)
``````

where
A2: is the cell where your data starts and the row you are filtering (in example A1 it is the header and it is filtered by first row),
{"amazon", "amz", "azamon"} – list of its conditions.

## Algorithms: given a list of strings, find each pair \$ (x, y) \$ where \$ x \$ is a sub sequence of \$ and \$. Possible to do better than \$ O (n ^ 2) \$?

Consider the following algorithmic problem: given a list of strings $$L = (s_1, s_2, dots, s_n)$$, we want to know all the pairs $$(x, y)$$ where $$x$$ it is a sequence of $$and$$. We can assume that all chains have a maximum length $$m$$, where $$m << n$$ and they are in a finite alphabet $$Sigma$$ with $$| Sigma | << n$$. We can also assume that the number of pairs $$(x, y)$$ where $$x$$ it is a sequence of $$and$$ is much smaller than $$n$$.

A trivial algorithm would be this:

``````1. foreach x in L:
2.   foreach y in L:
3.      if x is subsequence of y:
4.         OUTPUT x,y
``````

However, this has complexity $$O (n ^ 2 cdot m)$$ – I'm curious to know if there is a faster algorithm (faster given the number of pairs $$(x, y)$$ is much smaller than $$n$$, for example, an algorithm with complexity depending on the number of output pairs).

Note that this question is a follow-up to this question, which deals with the same problem but for substrings (not subsequences). There, the Aho-Corasick algorithm solved my problem perfectly: is there something like this but for sub-sequences?