I got this string
let reg = "(((T . (A . G)) + (T . C)) . (A + (C + (G* . T)))*)";;
For the given string I want to recursively count how many expressions in the form (expr simbol expr)->(A + C) exist in the string "reg". All possible values
(A . G);
(T . (A . G));
(T . C);
((T . (A . G)) + (T . C));
(G* . T);
(C + (G* . T));
(A + (C + (G* . T)));
(((T . (A . G)) + (T . C)) . (A + (C + (G* . T)))*)
and in end return 8;
I am not able to establish a stop condition for the recursive function. Any suggestion?
I can't really answer because (IMHO) your question isn't specific enough. To get a good answer you need to describe the possible inputs and the desired results very carefully.
It's not even clear whether the desired result is just a number (8 in your example), or if it should include an enumeration of all the subexpressions.
As I pointed out in the comments, if all the expressions are parenthesized then you don't need to work very hard to count them. You can simply count the number of left parentheses. You can check that this works for your example.
let count_lpar s =
let rec icount accum index =
if index >= String.length s then
accum
else
let accum' = if s.[index] = '(' then accum + 1 else accum in
icount accum' (index + 1)
in
icount 0 0
Here's how it works on your example string:
val count_lpar : string -> int = <fun>
# count_lpar "(((T . (A . G)) + (T . C)) . (A + (C + (G* . T)))*)";;
- : int = 8
The helper function icount is, indeed, a recursive function. The stop condition is that it reaches the end of the string.
If you need to enumerate the expressions, again assuming that the expressions are always parenthesized, then you can do this by locating the matching right parenthesis of every left parenthesis. You can do this by counting +1 for every left parenthesis and -1 for every right parenthesis and scanning until the count reaches 0.
If your input has a more general form, you need to describe it more carefully if you want to get help from StackOverflow. A careful description cna't be something like "here's an example". It would have to be something like "here's a context free grammar that generates all the possible inputs".
Related
Problem Statement: The Fibonacci word sequence of bit strings is defined as:
F(0) = 0, F(1) = 1
F(n − 1) + F(n − 2) if n ≥ 2
For example : F(2) = F(1) + F(0) = 10, F(3) = F(2) + F(1) = 101, etc.
Given a bit pattern p and a number n, how often does p occur in F(n)?
Input:
The first line of each test case contains the integer n (0 ≤ n ≤ 100). The second line contains the bit
pattern p. The pattern p is nonempty and has a length of at most 100 000 characters.
Output:
For each test case, display its case number followed by the number of occurrences of the bit pattern p in
F(n). Occurrences may overlap. The number of occurrences will be less than 2^63.
Sample input: 6 10 Sample output: Case 1: 5
I implemented a divide and conquer algorithm to solve this problem, based on the hints that I found on the internet: We can think of the process of going from F(n-1) to F(n) as a string replacement rule: every '1' becomes '10' and '0' becomes '1'. Here is my code:
#include <string>
#include <iostream>
using namespace std;
#define LL long long int
LL count = 0;
string F[40];
void find(LL n, char ch1,char ch2 ){//Find occurences of eiher "11" / "01" / "10" in F[n]
LL n1 = F[n].length();
for (int i = 0;i+1 <n1;++i){
if (F[n].at(i)==ch1&&F[n].at(i+1)==ch2) ++ count;
}
}
void find(char ch, LL n){
LL n1 = F[n].length();
for (int i = 0;i<n1;++i){
if (F[n].at(i)==ch) ++count;
}
}
void solve(string p, LL n){//Recursion
// cout << p << endl;
LL n1 = p.length();
if (n<=1&&n1>=2) return;//return if string pattern p's size is larger than F(n)
//When p's size is reduced to 2 or 1, it's small enough now that we can search for p directly in F(n)
if (n1<=2){
if (n1 == 2){
if (p=="00") return;//Return since there can't be two subsequent '0' in F(n) for any n
else find(n,p.at(0),p.at(1));
return;
}
if (n1 == 1){
if (p=="1") find('1',n);
else find('0',n);
return;
}
}
string p1, p2;//if the last character in p is 1, we can replace it with either '1' or '0'
//p1 stores the substring ending in '1' and p2 stores the substring ending in '0'
for (LL i = 0;i<n1;++i){//We replace every "10" with 1, "1" with 0.
if (p[i]=='1'){
if (p[i+1]=='0'&&(i+1)!= n1){
if (p[i+2]=='0'&&(i+2)!= n1) return;//Return if there are two subsequent '0'
p1.append("1");//Replace "10" with "1"
++i;
}
else {
p1.append("0");//Replace "1" with "0"
}
}
else {
if (p[i+1]=='0'&&(i+1)!= n1){//Return if there are two subsequent '0'
return;
}
p1.append("1");
}
}
solve(p1,n-1);
if (p[n1-1]=='1'){
p2 = p1;
p2.back() = '1';
solve(p2,n-1);
}
}
main(){
F[0] = "0";F[1] = "1";
for (int i = 2;i<38;++i){
F[i].append(F[i-1]);
F[i].append(F[i-2]);
}//precalculate F(0) to F(37)
LL t = 0;//NumofTestcases
int n; string p;
while (cin >> n >> p) {
count = 0;
solve(p,n);
cout << "Case " << ++t << ": " << count << endl;
}
}
The above program works fine, but with small inputs only. When i submitted the above program to codeforces i got an answer wrong because although i shortened the pattern string p and reduces n to n', the size of F[n'] is still very large (n'>=50). How can i modify my code to make it works in this case, or is there another approach (such as dynamic programming?). Many thanks for any advice.
More details about the problem can be found here: https://codeforces.com/group/Ir5CI6f3FD/contest/273369/problem/B
I don't have time now to try to code this up myself, but I have a suggested approach.
First, I should note, that while that hint you used is certainly accurate, I don't see any straightforward way to solve the problem. Perhaps the correct follow-up to that would be simpler than what I'm suggesting.
My approach:
Find the first two ns such that length(F(n)) >= length(pattern). Calculating these is a simple recursion. The important insight is that every subsequent value will start with one of these two values, and will also end with one of them. (This is true for all adjacent values -- for any m > n, F(m) will begin either with F(n) or with F(n - 1). It's not hard to see why.)
Calculate and cache the number of occurrences of the pattern in this these two Fs, but whatever index shifting technique makes sense.
For F(n+1) (and all subsequent values) calculate by adding together
The count for F(n)
The count for F(n - 1)
The count for those spanning both F(n) and F(n - 1). We can achieve that by testing every breakdown of pattern into (nonempty) prefix and suffix values (i.e., splitting at every internal index) and counting those where F(n) ends in prefix and F(n - 1) starts with suffix. But we don't have to have all of F(n) and F(n - 1) to do this. We just need the tail of F(n) and the head of F(n - 1) of the length of the pattern. So we don't need to calculate all of F(n). We just need to know which of those two initial values our current one ends with. But the start is always the predecessor, and the end oscillates between the previous two. It should be easy to keep track.
The time complexity then should be proportional to the product of n and the length of the pattern.
If I find time tomorrow, I'll see if I can code this up. But it won't be in C -- those years were short and long gone.
Collecting the list of prefix/suffix pairs can be done once ahead of time
I need (as a part of larger proof) to proove that a * (b * c) equals (a * b) * c which is true because * is declared associative.
I can match one term with another but it is not what I need because I need to write a proof score in form
start
...
close
so I need to use apply or something like.
What I've tried is to mark associativity as an axiom:
eq [assoc] : x:Elt * (y:Elt * z:Elt) = (x * y) * z .
but I cannot apply it then either because I cannot substitue multiple arguments
%MONOID> show term
(c * (a * b)):Elt
%MONOID> apply -.assoc with x = a y = b z = c at term .
[Error] no successful parse
[Error]:
or maybe because this rule is marked as invalid (what is reported while applying other rules ):
** id-completion for rule: eq [assoc]: (x:Elt * (y:Elt * z:Elt)) = ((x * y) * z)
-- Generated rules:
none
-- Generated, but invalid rules:
eq [assoc]: (x:Elt * (y:Elt * z:Elt)) = ((x * y) * z)
how to apply associativity and how to apply equation with multiple arguments (cant find this in docs http://cafeobj.org/files/reference-manual.html#apply http://cafeobj.org/files/manual.pdf ) ?
To my knowledge, the user cannot directly apply associativity that has been defined as an attribute of an operation. It seems that the system will apply associativity automatically. As an example of using associativity in a proof consider the GROUP module below. The axioms in the GROUP module are for the left part of a group theory specification. Associatitivity is specified as an attribute on the operation signature of +. Suppose the we wish to prove that the right inverse equation holds.
mod* GROUP {
[ G ]
op 0 : -> G .
op _+_ : G G -> G { assoc }
op -_ : G -> G
var X : G
eq[left-identity] : 0 + X = X .
eq[left-inverse] : (- X) + X = 0 .
}
From GROUP we can prove that for all a the equation a + (- a) = 0 holds (right inverse). Equations are applied to terms and if the term matches an equation it is replaced with the other side of the equation.
set print mode fancy on
open GROUP .
op a : -> G .
start a + ( - a ) .
apply -.left-identity at (1) .
apply -.left-inverse with X = - a at (1 1) .
apply red at [2 .. 3] . -- Associativity used: see proof output and show module
apply reduce at term .
--> Proof Output
result 0 + a + - a : G
result - (- a) + - a + a + - a : G
result - (- a) + 0 + - a : G
result 0 : G
The show command shows the details of a module
show module
Considering the axioms only, the output of the show command shows the current axioms of the proof score.
eq [left-identity]: 0 + X = X .
eq [left-identity_ext_A-m]: A2 + 0 + X + A1 = A2 + X + A1 .
eq [left-identity_ext_A-r]: 0 + X + A1 = X + A1 .
eq [left-identity_ext_A-l]: A1 + 0 + X = A1 + X .
eq [left-inverse]: - X + X = 0 .
We can see that the system has generated a set of associative axioms
involving identity.
Conclusion
The apply command applies a rewrite rule to a term. The builtin {asscoc} attribute cannot be directly applied to a term, rather associativity is applied by the system. If you define associativity as an equation it can be applied directly by the user, but proofs are usually longer.
The application of your user written associativity equation would parse if commas were added between the variable assignments:
mod* ASSOC{
[Elt]
op _*_ : Elt Elt -> Elt
eq [assoc] : x:Elt * (y:Elt * z:Elt) = (x * y) * z .
}
The equation can be directly applied in both directions. First apply the left hand side of the [assoc] equation to the term.
open ASSOC .
ops a b c : -> Elt .
start c * (a * b) .
apply .assoc at term .
close
Next apply the right hand side of equation to the term.
open ASSOC .
ops a b c : -> Elt .
start (a * b) * c .
apply -.assoc with x = a, y = b, z = c at term .
I'm trying to make a function that will solve a univariante polynomial equation in Standard ML, but it keeps giving me error.
The code is below
(* Eval Function *)
- fun eval (x::xs, a:real):real =
let
val v = x (* The first element, since its not multiplied by anything *)
val count = 1 (* We start counting from the second element *)
in
v + elms(xs, a, count)
end;
(* Helper Function*)
- fun pow (base:real, 0) = 1.0
| pow (base:real, exp:int):real = base * pow(base, exp - 1);
(* A function that solves the equation except the last element in the equation, the constant *)
- fun elms (l:real list, a:real, count:int):real =
if (length l) = count then 0.0
else ((hd l) * pow(a, count)) + elms((tl l), a, count + 1);
now the input should be the coefficient if the polynomial elements and a number to substitute the variable, ie if we have the function 3x^2 + 5x + 1, and we want to substitute x by 2, then we would call the eval as follows:
eval ([1.0, 5.0, 3.0], 2.0);
and the result should be 23.0, but sometimes on different input, its giving me different answers, but on this imput its giving me the following error
uncaught exception Empty raised at:
smlnj/init/pervasive.sml:209.19-209.24
what could be my problem here?
Empty is raised when you run hd or tl on an empty list. hd and tl are almost never used in ML; lists are almost always deconstructed using pattern matching instead; it's much prettier and safer. You don't seem to have a case for empty lists, and I didn't go through your code to figure out what you did, but you should be able to work it out yourself.
After some recursive calls, elms function gets empty list as its argument. Since count is always greater than 0, (length l) = count is always false and the calls hd and tl on empty list are failed right after that.
A good way to fix it is using pattern matching to handle empty lists on both eval and elms:
fun elms ([], _, _) = 0.0
| elms (x::xs, a, count) = (x * pow(a, count)) + elms(xs, a, count + 1)
fun eval ([], _) = 0.0
| eval (x::xs, a) = x + elms(xs, a, 1)
UPDATE - Solution
Thanks to jacobm for his help, I came up with a solution.
// Folding Recursion
let reverse_list_3 theList =
List.fold_left (fun element recursive_call -> recursive_call::element) [] theList;;
I'm learning about the different ways of recursion in OCaml (for class) and for some exercise, I'm writing a function to reverse a list using different recursion styles.
// Forward Recursion
let rec reverse_list_forward theList =
match theList with [] -> [] | (head::tail) -> (reverse_list_1 tail) # [head];;
// Tail Recursion
let rec reverse_list_tail theList result =
match theList with [] -> result | (head::tail) -> reverse_list_2 tail (head::result);;
Now, I'm trying to write a reverse function using List.fold_left but I'm stuck and can't figure it out. How would I write this reverse function using folding?
Also, if anyone has good references on functional programming, the different types of recursion, higher-order-functions, etc..., links would be greatly appreciated :)
I find it helpful to think of the fold operations as a generalization of what to do with a sequence of operations
a + b + c + d + e
fold_right (+) 0 applies the + operation right-associatively, using 0 as a base case:
(a + (b + (c + (d + (e + 0)))))
fold_left 0 (+) applies it left-associatively:
(((((0 + a) + b) + c) + d) + e)
Now consider what happens if you replace + with :: and 0 with [] in both right- and left-folds.
It may also be useful to think about the way fold_left and fold_right work as "replacing" the :: and [] operators in a list. For instance, the list [1,2,3,4,5] is really just shorthand for 1::(2::(3::(4::(5::[])))). It may be useful to think of fold_right op base as letting you "replace" :: with op and [] with base: for instance
fold_right (+) 0 1::(2::(3::(4::(5::[]))))
becomes
1 + (2 + (3 + (4 + (5 + 0))))
:: became +, [] became 0. From this perspective, it's easy to see that fold_right (::) [] just gives you back your original list. fold_left base op does something a bit weirder: it rewrites all the parentheses around the list to go the other direction, moves [] from the back of the list to the front, and then replaces :: with op and [] with base. So for instance:
fold_left 0 (+) 1::(2::(3::(4::(5::[]))))
becomes
(((((0 + 1) + 2) + 3) + 4) + 5)
With + and 0, fold_left and fold_right produce the same result. But in other cases, that's not so: for instance if instead of + you used - the results would be different: 1 - (2 - (3 - (4 - (5 - 0)))) = 3, but (((((0 - 1) - 2) - 3) - 4) - 5) = -15.
let rev =
List.fold_left ( fun lrev b ->
b::lrev
) [];;
test:
# rev [1;2;3;4];;
- : int list = [4; 3; 2; 1]
Design a function f such that:
f(f(x)) == 1/x
Where x is a 32 bit float
Or how about
Given a function f, find a function g
such that
f(x) == g(g(x))
See Also
Interview question: f(f(n)) == -n
For the first part: this one is more trivial than f(f(x)) = -x, IMO:
float f(float x)
{
return x >= 0 ? -1.0/x : -x;
}
The second part is an interesting question and an obvious generalization of the original question that this question was based on. There are two basic approaches:
a numerical method, such that x ≠ f(x) ≠ f(f(x)), which I believe was more in the spirit of the original question, but I don't think is possible in the general case
a method that involves g(g(x)) invoking f exactly once
Well, here's the C quick hack:
extern double f(double x);
double g(double x)
{
static int parity = 0;
parity ^= 1;
return (parity ? x : f(x));
}
However, this breaks down if you do:
a = g(4.0); // => a = 4.0, parity = 1
b = g(2.0); // => b = f(2.0), parity = 0
c = g(a); // => c = 4.0, parity = 1
d = g(b); // => d = f(f(2.0)), parity = 0
In general, if f is a bijection f : D → D, what you need is a function σ that partitions the domain D into A and B such that:
D = A ∪ B, ( the partition is total )
∅ = A ∩ B (the partition is disjoint )
σ(a) ∈ B, f(a) ∈ A ∀ a ∈ A,
σ(b) ∈ A, f(b) ∈ B ∀ b ∈ B,
σ has an inverse σ-1 s.t. σ(σ-1(d)) = σ-1(σ(d)) = d ∀ d ∈ D.
σ(f(d)) = f(σ(d)) ∀ d ∈ D
Then, you can define g thusly:
g(a) = σ(f(a)) ∀ a ∈ A
g(b) = σ-1(b) ∀ b ∈ B
This works b/c
∀ a ∈ A, g(g(a)) = g(σ(f(a)). By (3), f(a) ∈ A so σ(f(a)) ∈ B so g(σ(f(a)) = σ-1(σ(f(a))) = f(a).
∀ b ∈ B, g(g(b)) = g(σ-1(b)). By (4), σ-1(b) ∈ A so g(σ-1(b)) = σ(f(σ-1(b))) = f(σ(σ-1(b))) = f(b).
You can see from Miles answer that, if we ignore 0, then the operation σ(x) = -x works for f(x) = 1/x. You can check 1-6 (for D = nonzero reals), with A being the positive numbers, and B being the negative numbers yourself. With the double precision standard, there's a +0, a -0, a +inf, and a -inf, and these can be used to make the domain total (apply to all double precision numbers, not just the nonzero).
The same method can be applied to the f(x) = -1 problem - the accepted solution there partitions the space by the remainder mod 2, using σ(x) = (x - 1), handling the zero case specially.
I like the javascript/lambda suggestion from the earlier thread:
function f(x)
{
if (typeof x == "function")
return x();
else
return function () {return 1/x;}
}
The other solutions hint at needing extra state. Here's a more mathematical justification of that:
let f(x) = 1/(x^i)= x^-i
(where ^ denotes exponent, and i is the imaginary constant sqrt(-1) )
f(f(x)) = (x^-i)^-i) = x^(-i*-i) = x^(-1) = 1/x
So a solution exists for complex numbers. I don't know if there is a general solution sticking strictly to Real numbers.
If f(x) == g(g(x)), then g is known as the functional square root of f. I don't think there's closed form in general even if you allow x to be complex (you may want to go to mathoverflow to discuss :) ).
Again, it's specified as a 32-bit number. Make the return have more bits, use them to carry your state information between calls.
Const
Flag = $100000000;
Function F(X : 32bit) : 64bit;
Begin
If (64BitInt(X) And Flag) > 0 then
Result := g(32bit(X))
Else
Result := 32BitInt(X) Or Flag;
End;
for any function g and any 32-bit datatype 32bit.
There is another way to solve this and it uses the concept of fractional linear transformations. These are functions that send x->(ax+b)/(cx+d) where a,b,c,d are real numbers.
For example you can prove using some algebra that if f is defined by f(x)=(ax+1)(-x+d) where a^2=d^2=1 and a+d<>0 then f(f(x))=1/x for all real x. Choosing a=1,d=1, this give a solution to the problem in C++:
float f(float x)
{
return (x+1)/(-x+1);
}
The proof is f(f(x))=f((x+1)/(-x+1))=((x+1)/(-x+1)+1)/(-(x+1)/(-x+1)+1)
= (2/(1-x))/(2x/(1-x))=1/x on cancelling (1-x).
This doesn't work for x=1 or x=0 unless we allow an "infinite" value to be defined that satisfies 1/inf = 0, 1/0 = inf.
a C++ solution for g(g(x)) == f(x):
struct X{
double val;
};
X g(double x){
X ret = {x};
return ret;
}
double g(X x){
return f(x.val);
}
here is one a bit shorter version (i like this one better :-) )
struct X{
X(double){}
bool operator==(double) const{
return true
}
};
X g(X x){
return X();
}
Based on this answer, a solution to the generalized version (as a Perl one-liner):
sub g { $_[0] > 0 ? -f($_[0]) : -$_[0] }
Should always flip the variable's sign (a.k.a. state) twice, and should always call f() only once. For those languages not fortunate enough for Perl's implicit returns, just pop in a return before the { and you're good.
This solution works as long as f() does not change the variable's sign. In that case, it returns the original result (for negative numbers) or the result of f(f()) (for positive numbers). An alternative could store the variable's state in even/odd like the answers to the previous question, but then it breaks if f() changes (or can change) the variable's value. A better answer, as has been said, is the lambda solution. Here is a similar but different solution in Perl (uses references, but same concept):
sub g {
if(ref $_[0]) {
return ${$_[0]};
} else {
local $var = f($_[0]);
return \$var;
}
}
Note: This is tested, and does not work. It always returns a reference to a scalar (and it's always the same reference). I've tried a few things, but this code shows the general idea, and though my implementation is wrong and the approach may even be flawed, it's a step in the right direction. With a few tricks, you could even use a string:
use String::Util qw(looks_like_number);
sub g {
return "s" . f($_[0]) if looks_like_number $_[0];
return substr $_[0], 1;
}
try this
MessageBox.Show( "x = " + x );
MessageBox.Show( "value of x + x is " + ( x + x ) );
MessageBox.Show( "x =" );
MessageBox.Show( ( x + y ) + " = " + ( y + x ) );