instruction stringlengths 0 29.8k ⌀ |
|---|
You can try using a optimization algorithm like Particle Swarm Optimization or Genetic Algorithms. Matlab has a professional toolbox for GA and there are many written in Java.
Or you can try using this: https://github.com/madflame991/gloptat. (It's in Java) (Function optimization like this was the topic of my bache... |
In my opinion, such transducers does not exist.
It is not possible to convert from base 2 to base 1, since the regular language $\{10^n\ |\ n \in \mathbb{N}\}$ would become $\{1^{2^n}\ |\ n \in \mathbb{N}\}$, which is nonregular. However, regular languages are closed under the translation by the finite state transdu... |
the answer is this:
the middle transition ``fertig`` is the shared action so this must be ran parallel, but after this there are 2 transitions which dont have to run parallel, one is ``kochen`` and the other is ``essen``.
assume, we are now in the point where ``fertig`` is done by both processes and now we have... |
I'd like to learn something about this optimization problem: For given non-negative whole numbers $a_{i,j,k}$,
find a function $f$ minimizing the expression
$$\max_k \sum_i a_{i,f(i),k}$$
An example using a different formulation might make it clearer:
You're given a set of sets of vectors like
{
{(3, 0, ... |
null |
Consider one specific useful function of our human brain: abstraction of object. Take the example of two pictures: if we are told the pictures are similar, we actually make conclusion about the aspects in which they are close to each other.
I'm considering whether machine can have the ability described. More accurat... |
Finding Feature Representation Such That Two Samples Are Similar in Feature Space |
|machine-learning|artificial-intelligence|neural-networks| |
Did you have a look at [principal component analysis][1]? It's basically the simplest of an array of dimension-reducing methods. It does the following:
Given a set of data points with with dimension, say, $n$, it transforms them into data points with dimension $k<n$, where $k$ is a parameter. The transformation is s... |
IPv6 addresses in the form of `862A:7373:3386:BF1F:8D77:D3D2:220F:D7E0` are much harder to memorize or even transcribe than the 4 octets of IPv4.
There [have](http://blog.jgc.org/2011/07/pronounceable-ipv6-addresses-wpa2-psk.html?m=1) [been](http://www.halfbakery.com/idea/IPv6_20Worded_20Addresses#1260513928) atte... |
Weak hashing function for memorable IPv6 addresses |
|hash| |
I have this finite-state process with corresponding the corresponding labeled transition system:
![enter image description here][1]
[1]: https://i.stack.imgur.com/mxLLU.png
The FSP is:
MAKER = (kochen -> fertig -> MAKER).
USER = (fertig -> essen -> USER).
||MAKER_USER = (USER||MAKER).... |
|finite-automata|process-algebras| |
We cannot discuss the complexity of a problem when the problem size is fixed to a constant, because (most part of) the complexity theory deals with the asymptotic behavior of the complexity of the problem as the problem size tends to infinity. Here, I consider both the number of rows and the dimention of the vectors a... |
I have this finite-state process with the corresponding labeled transition system:
![enter image description here][1]
[1]: https://i.stack.imgur.com/mxLLU.png
The FSP is:
MAKER = (kochen -> fertig -> MAKER).
USER = (fertig -> essen -> USER).
||MAKER_USER = (USER||MAKER).
Why is ``e... |
null |
The only paper I can find about an implementation of a lossless video codec is an article by Michael Niedermayer: http://www.ffmpeg.org/~michael/ffv1.html which explains the FF1V compression pipeline.
I'm wondering if anyone else has found any articles similar to this. I've looked on IEEE and ACM and their articles ... |
Lossless Video Compression Pipeline |
|data-compression|video| |
Does there exist any data structure that efficiently (sublinear time insertion, removal, traversal) implements an ordered set (i.e. a set that allows for enumerating the items in insertion order)?
If so, what data structure is it/how does it do this? |
Sub-linear-time ordered set (!= sorted set) implementation? |
|data-structures| |
Does there exist any data structure that efficiently (sublinear time insertion/search/removal) implements an ordered set (i.e. a set that allows for enumerating the items in insertion order)?
If so, what data structure is it/how does it do this? |
null |
Does there exist any data structure that efficiently (linearithmic-or-similar in-order traversal, sublinear time insertion/search/removal) implements an ordered set (i.e. a set that allows for enumerating the items in insertion order)?
If so, what data structure is it/how does it do this? |
Okay, I guess this is just a case of me being silly... thanks to the people who commented above who made me realize this.
I can just use a hashtable, and keep a counter along with the item.
To traverse in order of insertion? Just dump it into an array and sort it with respect to the counter.
Traversal is O(... |
Reduction from 3SAT to the two-vector version: given a formula, let $i$ index variables, $j \in \{0,1\}$, and $k$ index clauses. Let $a_{i,j,k}$ be the number of times variable $i$ appears positively (if $j = 0$) or negatively (if $j = 1$) in clause $k$. OPT is less than $3$ iff the formula is satisfiable (the bijectio... |
Reduction from 3SAT to the two-vector version: given a formula, let $i$ index variables, $j \in \{0,1\}$, and $k$ index clauses. Let $a_{i,j,k}$ be the number of times variable $i$ appears positively (if $j = 0$) or negatively (if $j = 1$) in clause $k$. OPT is less than $3$ iff the formula is satisfiable (the bijectio... |
null |
Another pretty simple solution is a balanced binary search tree with threading (an overlaid linked list passing through all the nodes of the tree in order of their original insertion). Then insertion/search/removal are all O(log n), and iteration is O(n). You just update insert/remove to either append to the linked lis... |
A slight variant to Dijkstra algorithm will work on a graph with negative weight, without negative cycle (Competitive Programming 2, Steven Halim). For a general graph (which may contain negative cycle), use [Bellman-Ford][1] algorithm, which has fixed time complexity of O(VE), but guarantees termination, and allow det... |
null |
null |
null |
Is there any formal definition about the average height of a binary tree?
I have a tutorial question about find the average height of a binary tree using the following 2 method:
**1) natural solution might be to have the average length of the possible
paths from the root to a leaf.**
2) the average height for... |
What is the average height of a binary tree? |
|binary-trees| |
I am interested in exploring the world of [BDI agents](http://en.wikipedia.org/wiki/BDI_software_agent) (software agents that possess "beliefs, desires, intentions", essentially the agent has knowledge of the world, a set of motivations, and carries out certain plans).
I recently read "A Canonical Agent Model for He... |
Canonical reference on agent-based computing for mere mortals |
|agent-based-computing| |
Canonical reference on agent-based computing |
|reference-request|agent-based-computing| |
Let $\sf{Bubble Sort}$ be defined as the following:
for (i = 0; i < A.length - 1; i++)
for (j = i + 1; j < A.length; j++)
if (A[j] < A[i])
swap(i, j, A)
Given some permutation $x_1, \cdots, x_n$, an *inversion* is said to have occurred if $x_j < x_i$ for some $i < j.$ We... |
**Short answer.**<br>
To elaborate on Xodarap's response: if we formulate an appropriate *decision problem* version of the Discrete Logarithm problem, we can show that it belongs to the intersection of the complexity classes **NP**, **coNP**, and **BQP**.
<br>
**A decision problem version of Discrete Log.**<br>
T... |
### Short answer
The thesis that *all reasonable models of computation are polynomially-equivalent* — that is, in the amount of work that they perform; whether sequentially or in parallel, albeit different by some polynomial scaling factor — is generally known as the *Strong Church-Turing thesis* or the *E... |
null |
I think you're looking for [metric learning][1] or [Manifold learning][2]. At a very high level, the idea behind both of these approaches is to learn the space (or transform) over which a set of (labeled) examples are close to one another.
[1]: http://www.cse.ohio-state.edu/~kulis/pubs/metriclearning_icml.pdf
... |
It seems to be that your second calculation is incorrect.
Let the height of a subtree with a single node (i.e. a leaf) be 0. Then the height of the subtree root at:
- height at 4 is 0
- height at 3 is 0
- height at 2 is average height at 3 + 1 = 0 + 1 = 1
- height at 1 is average of heights at 2 and 3 = ... |
What's the definition of Kolmogorov complexity for a decision problem? For example, how to define the length of the shortest program that solves the 3SAT problem? Is it the "smallest" Turing machine that recognizes the 3SAT langauge? |
Kolmogorov complexity of a decision problem |
|decision-problem|kolmogorov-complexity|3-sat| |
My understanding of this question is that you have a two lists of $n$ two-dimensional coordinates. The first list represents the position of a bunch of agents (robots, maybe, or police cars). The second list represents where those agents need to go (which places need to have police cars dispatched to them), and may be ... |
Suppose we have $N$ fixed points (set $S$ with $|S|=N$) on the plane and $m$ agents with fixed, known initial positions ($m<N$) outside $S$. We should transfer the agents so that in our final configuration they are all positioned to different points of $S$. How could we achieve it by minimizing the total distance cove... |
Assign m agents to N points by minimizing the total distance |
|algorithms| |
If this were true, then the halting problem would be decidable. You would just record each (tape, state) pair seen when executing the Turing machine, and the machine would either halt (in which case it obviously halts), or you see a pair that you've seen before, in which case the machine does not halt.
Since the ha... |
|algorithms|graphs|optimization| |
Check out this link: http://projecteuclid.org/DPubS/Repository/1.0/Disseminate?view=body&id=pdf_1&handle=euclid.pja/1195520719
This is a simpler version of a proof by Chomsky that NSE grammars represent regular languages. Fortunately, the proof technique illustrates how to construct a left-regular grammar from a giv... |
Please note that I am aware the undecidability of the conversion of context-free grammer to regular grammer. But given the non-embedding property of the input context-free grammer, is there any algorithm to convert it to regular grammer, or DFA directly? |
How to convert a non-embedding context free grammer to regular grammer? |
|formal-languages| |
If you want to approach this field from a computer science perspective then the standard reference I would recommend is:
> Yoav Shoham and Kevin Leyton-Brown [2009], "Multiagent systems: algorithmic, game-theoretic, and logical foundations", Cambridge University press.
Currently, it seems like the focus of theore... |
I'm not sure if this question belongs here and I apologize if not. What I am looking to do is to develop a programmatic way in which I can probabilistically determine whether a given string "belongs" in a bag of strings. For example, if I have bag of 10,000 US city names, and then I have the string "Philadelphia", I ... |
Determining how similar a given string is to a collection of strings |
|algorithms| |
null |
|computability|turing-machines| |
|computability|decision-problem|kolmogorov-complexity|3-sat| |
We can view of a language $A$ as an infinite binary string (the infinite binary string corresponding to the characteristic function of $A$) and then use the notion of Kolmogorov complexity for such strings.
Google for: Kolmogorov complexity infinite words |
|graphs|combinatorics|binary-trees| |
|computability|terminology|turing-machines|church-turing-thesis| |
|algorithms|complexity-theory|optimization|linear-programming| |
|automata|finite-automata|process-algebras| |
|computer-networks|hash| |
|automata|finite-automata| |
|formal-languages|regular-languages|regular-expressions| |
|logic|lambda-calculus|semantics|reflection| |
|complexity-theory|np-complete|reductions|satisfiability|polynomial-time| |
Is there any formal definition about the average height of a binary tree?
I have a tutorial question about find the average height of a binary tree using the following 2 method:
1. **natural solution might be to have the average length of the possible
paths from the root to a leaf.**
2. the average height for... |
null |
Some better statistics to think of are word length and $n$-gram analysis. For word length, you can collect statistics of the distribution of word length of city names, and compare it to the length of what you get. $n$-gram analysis looks at the distribution of sequences of $n$ letters in your sample text (say $n=2$). B... |
Like Kaveh said, you can view a decision problem as a language consisting of the descriptions of all the "yes" instances. Then the Kolmogorov complexity of the language is, as you said, the length of the smallest program that produces all those descriptions.
How we describe the program that generates the instances (... |
null |
|algorithms|graphs|algorithm-analysis| |
|complexity-theory|np-complete|reductions|np-hard| |
|formal-languages|computability|automata|finite-automata| |
|asymptotics|recurrence-relation|mathematical-analysis| |
|computability|terminology|decision-problem| |
Computability over mathematical structure is a long and well established area of research. For example, see:
* Edward R. Griffor, "[Handbook of Computability Theory][1]", 1999
* Leonidovich Ershov, "[Handbook of Recursive Mathematics: Recursive Algebra, Analysis and Combinatorics][2]", 1998
or google for:
... |
|algorithms|dynamic-programming| |
|graphs|combinatorics| |
|complexity-theory|time-complexity|asymptotics|hash-tables| |
|formal-languages|regular-languages|automata|finite-automata| |
|graphs|terminology|combinatorics| |
|programming-languages|typing|java|type-inference| |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.