(b) Explain (in English), how would you convert the above DFA to a DFA that accepts all words that end with the same pattern ‘abbaa’.

# Tag: accepts

## formal languages – I am trying to design an LL(1) Parser that accepts T = {a, b *, +, ?, E, U, (, ) }

I am trying to design an LL(1) Parser that accepts regular notation where ‘E’ represents epsilon, and ‘U’ represents “or” like ‘ | ‘.

So far I made one that accepts T = { a, b, *, +, (, ), E}

```
S -> T S'
S' -> + S | ε
T -> F T'
T' -> T | ε
F -> P F'
F' -> * F' | ε
P -> ( S ) | c | E
c -> D M
M -> C | ε
D -> a | b
```

I am having trouble on what production I should add so that it will accept ‘U’ and ?. so it will allow something like these:

```
(a* U b+)* U a U E
E
```

but hopefully won’t allow these:

```
(a*)*
(a*)+
(a*)? - doesn't need optional because a* is already Zero or More
(a+)? - since this is basically a*
abE
```

I’ll be really grateful for any kind of help I can get 😀

## Single tape Turing Machine that accepts string with at least five G’s and at most three T’s?

I am looking to create a single tape acceptor Turing machine acting upon the language of any ASCII string, that would only accept strings that contains **at least** five G’s and **at most** three T’s, and rejects any other ASCII string input. I am kind of stuck on how the machine would know that it had encountered greater than or equal to five G’s **and** less than or equal to three T’s.

## Find a linear bounded automaton that accepts the language $L = { a^{n!} : n geq 0 }$

I need to construct linear bounded automaton for the language $L = { a^{n!} : n geq 0 }$. I know how LBA functions, however, I don’t have a thought how it can check the n! that to in the power of a. I might want to hear a few suggestions, as I am experiencing difficulty in developing the specific LBA for it.

## css – Mask that accepts numbers and letters

I have the following mask:

```
$('.form_fornecedor input#fornecedor_razao_social').mask('SSSS');
```

Currently the mask only accepts 4 letters… I need the mask to accept many letters and many numbers, without accepting special characters such as double and single quotes

## altcoin – If my service only accepts Bitcoin, will there be a lot of missed customers who only have non-Bitcoin crypto currencies?

I’m about to release a service which only takes payments in Bitcoin.

I’m wondering if this will impact me negatively in terms of not getting business from people who own other crypto currencies.

I don’t reject the others out of ideological reasons, but for practical ones:

- My hard disks are already overflowing from the 335.8 GB Bitcoin blockchain.
- I barely trust Bitcoin Core to run on my computer — I don’t trust non-Bitcoin clients whatsoever.
- Even if I did have the storage space and the trust, I would have to learn the respective RPC APIs (assuming they exist) for each “altcoin” as well. It took me a very long time to grasp the Bitcoin Core API.
- Any kind of reliance on a third-party service is unthinkable due to KYC/AML BS, as well as the obvious risk with getting my money stolen if somebody else “holds them for me”.

Is there any way around this? Is there some kind of mega-trusted “multi-coin” client which doesn’t need to download the entire blockchains, yet is able to securely and locally handle multiple of the biggest altcoins, so that I could support those for payments?

Or would anyone who has altcoins also have Bitcoin? I get the feeling that they are very, very few, but perhaps they are also more likely to spend their coins compared to the stubborn “HOLDers” of the increasingly valuable Bitcoin?

I know myself that I’m very unwilling to part from any of my Bitcoin, especially as the price is increasing… It’s just a fact for me, but I can’t speak for others. I don’t have any other crypto currencies myself, and the times I’ve looked into them, I’ve just been put off by their software. (In the cases where software even exists!)

Advice?

## ❕NEWS – Pizza Hut Accepts Bitcoin And Ethereum In Venezuela | NewProxyLists

## ssh – sshd never accepts public key offer

I have used PublicKey logins on a number of my servers for months without trouble. I generated the keys on my client machine and copied to the server’s ~/.ssh/authorized_keys using ssh-copy-id. All well and good until one machine stopped accepting key-based logins the other day. Obviously there has been a change, but the sshd_config is the same as it was and as the other server.

Running the connection verbosely offers the following:

```
debug1: Authentications that can continue: publickey,password
debug3: start over, passed a different list publickey,password
debug3: preferred gssapi-with-mic,publickey,keyboard-interactive,password
debug3: authmethod_lookup publickey
debug3: remaining preferred: keyboard-interactive,password
debug3: authmethod_is_enabled publickey
debug1: Next authentication method: publickey
debug1: Offering public key: /home/kapn/.ssh/id_rsa RSA SHA256: <deleted for post>
debug3: send packet: type 50
debug2: we sent a publickey packet, wait for reply
debug3: receive packet: type 51
debug1: Authentications that can continue: publickey,password
debug1: Trying private key: /home/kapn/.ssh/id_dsa
<and so on until it asks for a password>
```

My sshd_config file

```
Port 2201
PermitRootLogin without-password
PubkeyAuthentication yes
ChallengeResponseAuthentication no
UsePAM yes
TCPKeepAlive yes
# All else is at default settings.
# With the exception of the Port, PubKeyAuthentication and PermitRootLogin settings,
# I didn't intentionally change anything here.
```

Any thoughts on where to look for trouble? Is there data to be gathered other than via the -vv switch on ssh?

## complexity theory – For every $mathrm{NP}$ language $L$, is there a verifier such that, for all the certificates $u$ of other verifiers of $L$, it accepts $(x, u)$?

Fix $x in L$ of length $|x|=n$. Suppose that $mathcal{V}_q neq emptyset$, and let $m = q(n)$. Choose some $V^0 in mathcal{V}_q$. For any $s in {0,1}^m$, let $V^s(y,u) = V^0(y,u oplus s)$ for inputs of length $n$ and witnesses of length $m$, $V^s(y,u) = 0$ for inputs of length $n$ and witnesses lengths different from $m$, and $V^s(y,u) = V^0(y,u)$ otherwise. Then $V^s$ is a verifier for $L$ for all $s$, and so $bigcup_{V in mathcal{V}_q} V_x = {0,1}^m$.

This means that if a verifier $bar{V}$ exists, then $bar{V}_x$ is the set of all strings of length $q(|x|)$. This means that $bar{V}$ need not consult its witness, showing that $L in mathsf{P}$.

## Is there only one unique DPDA that accepts a specific language?

Or is it possible to construct more than one DPDA that accepts exactly the same language?