Can this language be called regular?

Recently, I was facing some problems in effectively proving the following :

Consider the alphabet Σ ={0,1,2,…,9,#}, and the language of strings of the form x#y#z, where x,y and z are strings of digit such that when viewed as numbers, satisfy the mathematical equation x+y=z.

Is this language regular and why ?

I was trying to apply the Pumping Lemma, but am unsure of how to complete the proof. Could anyone please help ?

What is the history of the offline networked mapping tool called Gametable?

Gametable was designed as a networked virtual table top for role playing use. It was comparable to tools such as MapTool, Roll20, Battlegrounds, and others. It’s popularity lay in the utter simplicity of use, virtually no learning curve, and decent if simple tool set.

But after the early 2010’s it fell out of popularity and practically disappeared from search results and reviews.


Thus, what is the history of the offline networked mapping tool called Gametable, as described in the Gametable tutorial link below?

https://www.roleplayingtips.com/articles/gametable_mapping_tutorial.html

How is it called when f(g(x)) = x?

There are a couple of function pairs which lead to the identity if applied after each other, e.g.

  • decrypt(encrypt(value)) == value
  • deserialize(serialize(data, filepath)) == data

How is this property called? Suppose one function undoes the property of the other one and it is guaranteed that this is possible for all values (within the domain of interest).

C++: will copy constructor and overload constructor be called simultaneously? [closed]

Assuming there is a class defined as:

class A: { public:    A(); // Default constructor        A(int m); // Overload constructor        A(const A& other); // Copy constructor }; 

I am wondering for the statement A b=A(5), which constructor will be applied?

Is A b=A(5) equivalent to A b(5)?

Already know that A a(5) calls the overload constructor only.

There are some books say overload constructor will be called first and then copy constructor. A(5) will create a temp object by calling overload constructor. Then the copy constructor for b will take the temp object as the argument.

I have tried some experiments in my local machine but getting overload constructor called only. Not sure if this issue depends on compiler.

Sets in Mathematics are immutable but in Computer Science sets are mutable and called “Dynamic Sets” – truth of the statement

While reading the classic text Introduction to Algorithms by Cormen et. al. I came across the following claim:

Sets are as fundamental to computer science as they are to mathematics. Whereas mathematical sets are unchanging, the sets manipulated by algorithms can grow, shrink, or otherwise change over time. We call such sets dynamic.

I felt a bit odd after reading the statement that "set" in Mathematics and in CS are different from the mutable point of view. Now in Mathematics what we deal with are theoretical aspect of things and as such "set" is a theoretical concept and so it is in Theoretical CS. If it is immutable in mathematics then so it is in CS. Mathematics and Theoretical CS are interlinked. So given a graph algorithm which say finds the minimum shortest path between a pair of vertices , we can’t say whether it belongs to Mathematics or CS.

Often in algorithms we write statements as :

$ $ S = S \cup \{a\} \quad \text{view $ 1$ }$ $

Which seems to sort of change our set $ S$ , but if we look it in this way:

$ $ S’= S \cup \{a\} \quad \text{view $ 2$ }$ $

$ $ S=S’$ $

So in the second situation we are not modifying our actual set $ S$ we are forming a new set $ S’$ with $ S$ augmented with $ a$ and then after that we are making the variable $ S$ refer to $ S’$ .

What I feel is that the concept of the set being mutable or immutable is solely dependent on the data-structure of representation of the abstract concept of "sets" and since in data-structure the two steps in view $ 2$ are combined and implemented, so they are called dynamic sets.

In short I feel that Dynamic Sets are data-structure implementation of sets and not the abstract sets.

Are called shots actually as powerful as designers believedd them to be?

I have been searching for interesting rules systems to make Pathfinder Combat more interesting in an E6 campaign, more cinematic, and to make classes relying on mundane attacks a bit more powerful. Called Shots seemed like exactly what I needed. Indeed, the effects they can inflict are sometimes actually crippling.

However, I was shocked by the investments required to make use of this mechanic.

  1. Like many mundane mechanics in Pathfinder, it requires two feats to function properly: Improved Called Shots and Greater Called Shots. Yes, Called Shots offer a greater array of available effects than, say, combat maneuvers do, but two feats is still a huge investment. Even for an E6 campaign.
  2. Those feats require Combat Expertise as a feat tax, so Called Shots actually cost three feats to work properly.
  3. Those feats require Int 13, which is not always the best choice for a martial character and doesn’t really make a lot of sense for an aiming feat (Dex 13 would make a lot more sense).
  4. There is a big opportunity cost in making a Called Shot even if you have both related feats. When you decide to make a Called Shot, you accept a huge penalty to your attack roll if you want to achieve anything significant (“Challenging” shots), quite likely just missing your target and achieving nothing at all.
  5. “Easy” shots, on the other hand, don’t threaten your opponent too much.
  6. However, speaking about crits, they are unreliable. Even when you build your character around crits.
  7. Debilitating blows’ effects are mostly amazing, but I plan to use those rules in E6.
  8. Most significant effects achieved by Called Shots allow for a saving throw to partially or fully negate them, to make the feat even more unreliable. At this level, 40 points of damage from a single attack are likely to guarantee this creature dropped within a turn or two, even without any additional debuffs.
  9. Apparently, the designers wanted those rules to be unreliable, because the standard rules make True Strike turn your Called Shot into a normal attack.
  10. If you target touch AC, you lose this benefit when using Called Shots, so Gunslingers and magic users stop being as accurate as they usually are.

In my games, I want to buff Called Shots significantly because they seem to be useless, those feats being trap options. The only possible way to use them now is to take Improved Called Shots, take an Easy Called Shot every time you make a full attack, and just hope for the best (the penalty from the shot will be offset by the bonus from a feat). However, I am not an expert in Pathfinder, so I am asking:

Am I misunderstanding something and underestimating the potential of Called Shots, or are they indeed yet another feat-intensive, trap option present in Pathfinder?