## Why does this latex code not display correctly in text cells

When I copy this latex code to a text cell of MMA, the typesetting is not correct. There are many line breaks in the result:

$$\begin{array}{*{20}{l}} {-1 < x < 1}\ {\mathop{{ \left( {1+x} \right) }}\nolimits^{{m}}=1+mx+\frac{{m{ \left( {m-1} \right) }}}{{2!}}\mathop{{x}}\nolimits^{{2}}+ \cdots +\frac{{m{ \left( {m-1} \right) } \cdots { \left( {m-n+1} \right) }}}{{n!}}\mathop{{x}}\nolimits^{{n}}+ \cdots }\ {\sqrt{{1+x}}=1+\frac{{1}}{{2}}x-\frac{{1}}{{2 \cdot 4}}\mathop{{x}}\nolimits^{{2}}+\frac{{1 \cdot 3}}{{2 \cdot 4 \cdot 6}}\mathop{{x}}\nolimits^{{3}}-\frac{{1 \cdot 3 \cdot 5}}{{2 \cdot 4 \cdot 6 \cdot 8}}\mathop{{x}}\nolimits^{{4}}+ \cdots }\ {\frac{{1}}{{\sqrt{{1+x}}}}=1-\frac{{1}}{{2}}x+\frac{{1 \cdot 3}}{{2 \cdot 4}}\mathop{{x}}\nolimits^{{2}}-\frac{{1 \cdot 3 \cdot 5}}{{2 \cdot 4 \cdot 6}}\mathop{{x}}\nolimits^{{3}}+\frac{{1 \cdot 3 \cdot 5 \cdot 7}}{{2 \cdot 4 \cdot 6 \cdot 8}}\mathop{{x}}\nolimits^{{4}}- \cdots } \end{array}$$ 

## Can one prevent Mathematica from adding ExpressionUUID to cells?

There are some well-known options for preventing the front end from adding “unnecessary” stuff to .nb files when keeping them e.g. in a git repository: CreateCellID, "FileOutlineCache" and "TrackCellChangeTimes".

However, recent Mathematica versions seem to add an ExpressionUUID to each cell, which makes the task of keeping .nb files in a repository more challenging.

So is there perhaps some dedicated option to turn that off and therefore get rid of ExpressionUUID in a given notebook?

YINUO Electronics China service center is a wholly owned subsidiary of Taiwan YINUO Electronics industry Co., Ltd in mainland China. The company locates in Ningbo Yinzhou industrial zone, which has professional technical team, excellent design ability, strict quality control and best customer service.
Our main products include force gauges, torque testers, test stands, torque sensors and various special testing equipment, which have been widely used in all kinds of home appliances, IT enterprises, wires and cables, motors, electrical appliances, instruments and meters, transformers, beverages, pharmaceuticals, automobiles, rail transit, aerospace and other industries.
In order to facilitate customers to obtain our products and services, we have set up offices and distribution points in key cities in mainland China. Meanwhile, we are also constantly developing overseas markets, and have already built extensive cooperation with world well-known manufacturers. Our products have exported to Taiwan, South Korea,Europe and the United States etc.
Adhering to the enterprise philosophy of “excellent quality, customer first, continuous innovation”, YINUO will be committed to improving the technical innovation and providing better service for our clients.Cylinder Load Cells price
website:http://www.ai-motive.com/

## Picross solving: matching checked cells to their clues

I am writing a picross solver, and I am going with the “human logic” solving, which attempts to reproduce the reasoning a human might have when confronted to such a puzzle, in an iterative manner.
Having solved a lot of those by hand, I found the human logic to be very algorithmic-ish given how the same kind of reasoning takes place in most situations (which is also what motivated me in writing a solver).
However, I am encountering problems when trying to formalize some of that logic.

# What is picross

Also called nonograms, they are puzzles consisting of an empty grid with clues on the top and left borders:

The clues indicate the length of groups of consecutive cells that need to be checked, and groups must be separated by at least one empty (unchecked) cell. Clues are ordered.
For example, clues 7 2 in the first row indicate that the following must take place somewhere in that row:

• 7 consecutive cells must be checked
• at least one cell must be left empty after that 7-long sequence
• another 2 consecutive cells must be checked after the empty cell(s)

Here is what the solved grid looks like:

In order to help in the process of solving, it is also possible to cross cells to indicate that they cannot be checked, as in they must remain empty for sure.

# Trivial solving

The easiest part of the solving is filling the empty grid with what you can deduce from the clues alone in each row and column. In that regard, some clues are nice, and some clues are not so nice.
For example, given that the previous grid is 10 cells wide, and that clues 7 2 fit in exactly 10 cells (7 checks + 1 space + 2 checks), there is only one possible solution for the first row.
However, by looking at the second row and its clue 6, you will only be able to find that only cells at columns 5 and 6 can be checked with certainty:

|■|■|■|■|■|■| | | | |     1. Check the 6 leftmost cells           ↓ | | | | |■|■|■|■|■|■|     2. Slide the group all the way to the right           ↓ | | | | |■|■| | | | |     3. Keep cells that are *always* checked during the sliding 

You can generalize this reasoning to a group of several clues by calculating the minimum space in which they fit, computing the difference with the actual available space and checking cells at only certain indices depending on those two numbers.
As mentioned, this is the easy part, because it only depend on the clues. It assumes the row or column is empty and thus it doesn’t take its state into account.

# Further (iterative) solving

From that point onwards, several other pieces of reasoning can be performed in a loop on each row and column, and that will be sufficient to solve the entire grid in most cases. This paper, from section 2.2.2 (p. 16), identifies all such techniques. There is one problem however: these reasonings take into account the current state of a row or column, they build upon it. What that means is that in order for most of those to be carried out, they need to know which group of checked cells may correspond to which clue.

For example, considering the following row (10-wide with clues 3 4):

3 4║ | | | | |■| | |■| ║ 

an algorithm identifying which cell may belong to which clue would tell me the following:
both cells 6 and 9 belong to clue 4
Reason: if cell 6 belonged to clue 3, a group satisfying clue 4 would not fit in the row (at least while being properly separated by an empty cell, as required). Cell 9 cannot belong to clue 3 for the same reason, as well as because cell 6 is located before and was found to exclusively belong to clue 4, which is after clue 3.

For the following row:

3 4║ | | |■|■| |■| | | ║ 

the algorithm would tell me:
cells 4 and 5 belong to clue 3, and cell 7 belongs to clue 4
Reason: if cells 4 and 5 belonged to clue 4, a group satisfying clue 3 would not fit in the row. In the same way, there would not be enough space to satisfy clue 4 if cell 7 belonged to clue 3.

Finally, for the following row:

3 4║ | | | |■| |■| | | ║ 

the algorithm would tell me: cell 5 belongs to either clue 3 or clue 4, but cell 7 belongs to clue 4 for sure
Reason:

• if cell 5 belongs to clue 3, there is still enough space for both a group of three ending at cell 5 and a group of four beginning at cell 7. Cell 5 may belong to clue 3.
• if cell 5 belongs to clue 4, there is still enough space for both a group of three starting at cell 1 and a group of four starting at cell 5. Cell 5 may belong to clue 3.
• if cell 7 belongs to clue 4, there is plenty of space for both groups required by clues. Cell 7 may belong to clue 4.
• if cell 7, however, belonged to clue 3, there would not be enough space for a group satisfying clue 4 afterwards. Cell 7 may not belong to clue 3.

And this is exactly that algorithm which I’m having trouble writing down.
It also turns out I was able to come up with a solution while writing this question. See my (rather long) self-answer below.

## Is it decidable whether a given Turing machine moves its head more than 481 cells away from the left-end marker, on input?

So, while reading some problems on decidability, I came across the following resource: https://www.isical.ac.in/~ansuman/flat2018/tm-more-undecidable.pdf

Here, on page no 12, it is written that the problem is decidable and with the following argument:

“Yes, Simulate M on for upto m^481 · 482 · k steps. If M visits the 482nd cell, accept, else reject.”

I am quite confused with the step count. Can anyone please explain what does this mean, or maybe point to some resources where I can find a proper explanation!!!! Image of the slide

## Algorithm for competing cells of 0s and 1s. Can it be made faster?

I’m working on a practice algorithm problem, stated as follows:

There are eight houses represented as cells. Each day, the houses compete with adjacent ones. 1 represents an “active” house and 0 represents an “inactive” house. If the neighbors on both sides of a given house are either both active or both inactive, then that house becomes inactive on the next day. Otherwise it becomes active. For example, if we had a group of neighbors [0, 1, 0] then the house at [1] would become 0 since both the house to its left and right are both inactive. The cells at both ends only have one adjacent cell so assume that the unoccupied space on the other side is an inactive cell.

Even after updating the cell, you have to consider its prior state when updating the others so that the state information of each cell is updated simultaneously.

The function takes the array of states and a number of days and should output the state of the houses after the given number of days.

Examples:      input: states = [1, 0, 0, 0, 0, 1, 0, 0], days = 1     output should be [0, 1, 0, 0, 1, 0, 1, 0]     input: states = [1, 1, 1, 0, 1, 1, 1, 1], days = 2     output should be [0, 0, 0, 0, 0, 1, 1, 0] 

My solution:

def cell_compete(states, days):     for _ in range(days):         prev_cell, next_cell, index = 0, 0, 0         while index < len(states):             if index < len(states) - 1:                 next_cell = states[index + 1]             elif index == len(states) - 1:                 next_cell = 0             if next_cell == prev_cell:                 prev_cell = states[index]                 states[index] = 0             else:                 prev_cell = states[index]                 states[index] = 1             index += 1     return states 

I originally thought to take advantage of the fact they are 0s and 1s only and to use bitwise operators, but couldn’t quite get that to work.

Can I improve the efficiency of this algorithm? Any ideas on the “optimal” solution?

Appreciate any feedback, thanks!

## SSRS – Get LookupSet results on different cells

Sorry if I’m missing something obvious but I’m a newbie to SSRS (SQL Server 2012 R2) and SharePoint 2010.

My boss wants some basic reports from our internal SP site (list data) and I’m doing some research on SP + SSRS. Fields from more than one list are needed so I used the LookUp expression on Report Builder/BIDS to generate a sample report.

Here’s the details. I’ve got two separate lists:

1. PROJECT (containing columns “ProjectID” and “TasksID”) and

I want to generate a basic report displaying the total Hours (mini tasks) spend on different Tasks grouped by Project, on which they are belonging to.

Here’s what I got so far: http://imgur.com/b44mFRj (bypass the Greek nonsense, its Projects – Tasks – Description – Hours)

For the last 2 columns I used the expressions:

=Join(LookUpSet(Fields!TaskID.Value, Fields!TaskID.Value, Fields!Description.Value, "Dataset2"), " " + vbcrlf) 

and

=Join(LookUpSet(Fields!TaskID.Value, Fields!TaskID.Value,Fields!Hours.Value, "Dataset2"),"" + vbcrlf) 

The result is an array of strings so as a first step I joined them with Join and separated them by newline. This messed things up cause I cant get the totals I need (total Hours spend on Task, total Hours spend on Project, total Hours for all Projects etc).

Are there any ways to get the results on different cells so I can work with them?

Thanks – Sorry for the big intro.

## How to highlight cells in one table as matching cells in another table are highlighted

I have two tables in an html document <table id="table1"> and <table id="table2">.
There are 10 columns and 5 rows in each table.
Each cell contains either one or two alphanumeric or special (e.g. *, \$ , % etc) characters.

I would like it to function as follows:

When I hover or select a cell (on a specific row – e.g. top row) of table1, e.g. containing the "Z" character, then the "Z" character will be highlighted /selected on table2 if it appears on the same specific row (i.e. top row of…

How to highlight cells in one table as matching cells in another table are highlighted

## Mass / batch – update / edit cells with in a grid

I am looking for some ideas on the UX of allowing a user to edit multiple cells in a grid at one time. These users may have thousands of records and they need to provide data on each record, this data may be duplicated across multiple records so I am trying to figure out a clean way to allow them to apply a value to multiple cells easily.

Hoping to not implement excel in my application.

Any help would be appreciated 🙂

## Segmenting cells from a stained image of cells from microscope

I have an image which has stained cells and I have to segment all the cells.

But the problem is that the cell boundary is not very distinguished where there is staining done because of the stain.

Can someone kindly help me with segmenting the image and getting cell boundary?

I tried various filters like RidgeFilter, DerivativeFilter, GaussianFilter and combination of them.

I am using Mathematica 12.