## Algorithms – How to generate a deterministic finite state machine for a given language

Problem: Write a program that generates a deterministic finite automaton that accepts the given language. The language is defined with the alphabet and the start / end substrings.

For example: alphabet = {a, b, c}; start sub string = "down"; end sub string = "cb"

I need to construct DFA that accepts strings of the type: {abcb, abaacb, abcabcb …}.

Question: What algorithm should I use to write functions that create DFAs for this series of problems?

## Algorithms – Trigonometry and possibilities for implementation by arithmetic

 If you're trying to hand in a response in trigonometry based on an input $$f (n)$$ and $$n$$ is your input, then you will want to find $$n ^ 2$$ first. because

$$n = sqrt {t}$$

 And it will correlate directly with the outputs of the trigonometric functions

$$tan ^ {- 1} (n) = f ( frac {n} {t} – frac {t} {n} – frac {t} {n})$$
$$sin ^ {- 1} (n) = g ( frac {n} {t} – frac {t} {n})$$
$$cos ^ {- 1} (n) = h ( frac {t} {n} – frac {n} {t})$$, Below is the relationship of the input $$n$$ while it cuts with $$tan ^ {- 1} (n)$$, How is it directly under the function, how I created it?

 With much praise it seems that the functions $$sin$$ & $$cos$$ also train with your counterpart. The consistency usually over $$n$$ & $$t$$ still valid.

 How to find the trigonometric functions by simply calculating by hand.

## Algorithms – How to solve this equation step by step

I have to solve this equation for a job that I do. I try to answer based on an input. If I can, I will be very happy. Could someone show me how to do that step by step? It would be very rewarding for me to do this.

$$frac {n} {t} – frac {t} {n} – frac {t} {n}$$

This is the calculation for the tangent that I created. It works very well. The answer $$n$$ tangential is always that $$sqrt {t}$$ unless you implicitly do it $$n & # 39; = t$$ and $$t & # 39; = n$$

$$frac {n} {t} – frac {t} {n}$$ is sinus and $$frac {t} {n} – frac {n} {t}$$ is cosine.

If you apply the tangent, you can find the sine and cosine of these formulas.

Lastly, it may have negative answers for $$t$$ This seems to be common, but so far it has been biased to have a regular function to equate the why. (Millennium Prize?)

## Algorithms – Create a priority search tree to determine the number of points in the range [-inf, qx] X [qy, qy’] from a series of points sorted by y-coordinates

A priority search tree can be created for a set of points P in time O (n log (n)). However, if the points are sorted by the y-coordinates, it takes O (n). I find algorithms for constructing the tree if the points are not sorted.

I found a way to do this as follows:

1. Construct a BST on the points.
Since the points are sorted, it will take O (n) time

2. Min-heap the BST on the x-coordinates
This will take theta (n) time

The total time complexity will be O (n).

Is this a valid approach to creating a priority search tree in O (n) time?

## Algorithms – Image processing system (encryption / decryption) with Residue Number System

I am preparing for my final project at school and plan to work on the implementation of the Residue Number System in image processing.
I found this work online from Pallab Maji Here:

http://ethesis.nitrkl.ac.in/2831/1/Thesis_Final_App_of_RNS_in_Comm__SP.pdf

and I looked on pages 29 – 41, he explained the algorithm with which I do not know some concepts:

• I: input image and block size m and n.
• II: Divide the image into mxn blocks and scan the intermediate blocks in zigzag.
• III: Z = m × n × 8 bits. Create a module set P, where P = {p1, p2 … pk} and equals Z bits.
• IV: zigzag the scanned intermediate block into a word and scale it to avoid this
Overflow.
• V: Use the set P to convert the word to RNA.
• VI: Re-group the RNA number to form a word and further subdivide it into mxn
Blocks.
• VII: Match the encrypted block to the picture.

I would be very grateful if someone could help me enforce it.

## Algorithms – Find N best subset of quotes

I face the following problem:

We receive quotes from different forwarding companies for the shipping costs per parcel. Let's call these quotes Q1 … Qk.
Each offer is an M x N matrix with weight categories of packets along one axis and size categories along the other axis.
We get a list of packages with the appropriate weights and sizes, so we can also convert the packages to be sent based on the categorization of each package into a 2D matrix of size M x N and each cell must contain the appropriate number of packets in this weight + size category. Let's call this matrix P.

The total shipping cost for all packages, should we choose a shipping company, & # 39; i & # 39; is the sum of (Qi x P), where & # 39; x & # 39; is the elementwise multiplication of the two matrices.

We need to find a subset of shipping companies (or quotes) so that the total shipping cost is minimal.

I understand that a brute-force algorithm that tries all combinations will not work because the number of combinations explodes when & # 39; w & # 39; begins to increase. In addition, I've also convinced myself that I can not iteratively build a solution by first picking two best quotes, grouping them together, and then adding one more, until I & # 39; w & # 39; reach.

Can someone help me to find the appropriate problem class and propose a solution?

## Time complexity – Multiset variant of the subset problem of known algorithms

I have been working in the time analysis for a solver that I have designed for the subset sum problem (multiset variant) and whose time complexity depends on the number of repeated elements in the input.

The temporal complexity is $$O (2 ^ {n / 2} cdot 0,75 ^ { frac {d / 2} {n}})$$ Where $$d =$$ Number of duplicates in the input instance (both required) $$n$$ and $$d$$ are equal)

For example when $$d = n / 2$$ then:

$$O (2 ^ {n / 2} cdot 0,75 ^ { frac {n / 4} {n}}) approx. O (1,4142 cdot 0,93) approx. O (1,316 ^ n)$$

In addition to the question of comments, I'm also looking for other well-known algorithms with similar behavior to compare approaches (looking for them, but so far found nothing …)

## Algorithms – Distinct Binary Heaps

I have $$n$$ Elements off $$n-1$$ are different. The repeated element is either the minimum or the maximum element. I have to find out how many different clusters can be made from it.

My analysis : I started with $$n$$ different elements. Since the root is solid (maximum or minimum element), we can choose $$l$$(Determined by subtracting the total number of elements from the elements on the penultimate level.) $$n-1$$ Elements and select recursively for the left subtree and the right subtree.

Repeat Relationship:

$$T (n) = {n-1 choose l} * T (l) * T (r)$$

Now for $$n-1$$ different elements (given), for root we have $$2$$ Options, d. H. maximum elements, and we can proceed recursively as above for the left and right subtree. But since the repeated element is there as well, I can not figure out exactly how to do it.

e.g: $$A = (2,6,6)$$ =>
There are 2 different heaps.

I can not imagine how I can determine the number of heaps in this case. Can anyone think of algorithm / repetition relation to find something like that?

## Algorithms – Non-Boolean SAT – Computer Science Stack Exchange

I was wondering how complex SAT tests are with variables $$x_i = 0 lor 1 lor 2 dots lor n$$, where clauses are of the form $$x_i = a implies x_j neq b$$, When $$n = 2$$We have 2SAT with linear time algorithms. Meanwhile, if $$n> 2$$If we can then almost convert it to 2SAT by having Boolean variables $$x_ {i, a}$$ according to the statement $$x_i = a$$However, this allows $$x_ {i, 1} = x_ {i, 2} = dots = x_ {i, n} = 0$$that would leave $$x_i$$ unallocated.

## Algorithms – Truss Tree Collection Knot Combinations

Summary: I have a tree that contains car parts, from which I have to put together all valid combinations of these parts.

Parts may be required – each build must contain them.

Parts can be optional.

Parts may conflict with other parts.

Parts may include optional parts.

Example tree:

``````Car
| - Motor (required)
| - - V8
| - - V12
| - - - Colour (optional)
| - - - - Black
| - - - - Chrome
| - Transmission (required)
| - - Mechanical
| - - Automatic
| - Wheels (optional)
| - - Basic
| - - Fancy
| - - - Colour (optional)
| - - - - Red
| - - - - Blue
| - BodyStyle (optional)
| - - Hatchback (conflicts with Motor.V12)
| - - Buggy (conflicts with Motor.V8)
``````

Valid builds for this tree:

``````Car | Motor.V8 | Transmission.Automatic
Car | Motor.V8 | Transmission.Automatic | Wheels.Basic
Car | Motor.V12.Colour.Black | Transmission.Automatic | Wheels.Basic
Car | Motor.V8 | Transmission.Automatic | BodyStyle.Hatchback
Car | Motor.V12 | Transmission.Mechanical | Wheels.Fancy | BodyStyle.Buggy
Car | Motor.V12 | Transmission.Mechanical | Wheels.Fancy.Colour.Red | BodyStyle.Buggy
``````

What algorithm should I look for to solve this task?