aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Just another update

Browse source
This commit is contained in:
Ingy döt Net 2015-02-20 00:35:01 -05:00
parent a25938f123
commit 00a190b0a6
6591 changed files with 94363 additions and 23227 deletions
Download patch file Download diff file Expand all files Collapse all files

6
Task/Mutual-recursion/00DESCRIPTION
View file

@ -1,4 +1,5 @@
Two functions are said to be mutually recursive if the first calls the second, and in turn the second calls the first.
Two functions are said to be mutually recursive if the first calls the second,
and in turn the second calls the first.
Write two mutually recursive functions that compute members of the [[wp:Hofstadter sequence#Hofstadter Female and Male sequences|Hofstadter Female and Male sequences]] defined as:
:<math>
@ -9,4 +10,5 @@ M(n)&=n-F(M(n-1)), \quad n>0.
\end{align}
</math>
<br>(If a language does not allow for a solution using mutually recursive functions then state this rather than give a solution by other means).
<br>(If a language does not allow for a solution using mutually recursive functions
then state this rather than give a solution by other means).

6
Task/Mutual-recursion/Elixir/mutual-recursion.elixir Normal file
View file

@ -0,0 +1,6 @@
defmodule MutualRecursion do
def f(0), do: 1
def f(n), do: n - m(f(n - 1))
def m(0), do: 0
def m(n), do: n - f(m(n - 1))
end

10
Task/Mutual-recursion/REXX/mutual-recursion-1.rexx
View file

@ -1,11 +1,11 @@
/*REXX program shows mutual recursion (via Hofstadter Male & Female seq)*/
arg lim .; if lim=='' then lim=40; pad=left('',20)
parse arg lim .; if lim='' then lim=40; pad=left('',20)
do j=0 to lim; jj=Jw(j); ff=F(j); mm=M(j)
say pad 'F('jj") =" Jw(ff) pad 'M('jj") =" Jw(mm)
do j=0 to lim; jj=Jw(j); ff=F(j); mm=M(j)
say pad 'F('jj") =" Jw(ff) pad 'M('jj") =" Jw(mm)
end /*j*/
exit /*stick a fork in it, we're done.*/
/*─────────────────────────────────────F, M, Jw subroutines────────────*/
F: procedure; arg n; if n==0 then return 1; return n-M(F(n-1))
M: procedure; arg n; if n==0 then return 0; return n-F(M(n-1))
F: procedure; parse arg n; if n==0 then return 1; return n-M(F(n-1))
M: procedure; parse arg n; if n==0 then return 0; return n-F(M(n-1))
Jw: return right(arg(1),length(lim)) /*right justifies # for nice look*/

21
Task/Mutual-recursion/REXX/mutual-recursion-2.rexx
View file

@ -1,14 +1,15 @@
/*REXX program shows mutual recursion (via Hofstadter Male & Female seq)*/
arg lim .;if lim=='' then lim=99; hm.=; hm.0=0; hf.=; hf.0=1; Js=; Fs=; Ms=
parse arg lim .; if lim=='' then lim=99 /*get or assume LIM.*/
hm.=; hm.0=0; hf.=; hf.0=1; Js=; Fs=; Ms=
do j=0 to lim; ff=F(j); mm=M(j)
Js=Js jW(j); Fs=Fs jw(ff); Ms=Ms jW(mm)
do j=0 to lim; ff=F(j); mm=M(j)
Js=Js jW(j); Fs=Fs jw(ff); Ms=Ms jW(mm)
end /*j*/
say 'Js=' Js
say 'Fs=' Fs
say 'Ms=' Ms
say 'Js=' Js
say 'Fs=' Fs
say 'Ms=' Ms
exit /*stick a fork in it, we're done.*/
/*─────────────────────────────────────F, M, Jw subroutines────────────*/
F: procedure expose hm. hf.; arg n; if hf.n=='' then hf.n=n-M(F(n-1)); return hf.n
M: procedure expose hm. hf.; arg n; if hm.n=='' then hm.n=n-F(M(n-1)); return hm.n
Jw: return right(arg(1),length(lim)) /*right justifies # for nice look*/
/*──────────────────────────────────one─liner subroutines──────────────────────────────*/
F: procedure expose hm. hf.; parse arg n; if hf.n=='' then hf.n=n-M(F(n-1)); return hf.n
M: procedure expose hm. hf.; parse arg n; if hm.n=='' then hm.n=n-F(M(n-1)); return hm.n
Jw: return right(arg(1),length(lim)) /*right justifies # for nice look*/

16
Task/Mutual-recursion/REXX/mutual-recursion-3.rexx
View file

@ -1,18 +1,18 @@
/*REXX program shows mutual recursion (via Hofstadter Male & Female seq)*/
/*If LIM is negative, only show a single result for the abs(lim) entry.*/
parse arg lim .; if lim=='' then lim=99; aLim=abs(lim)
parse arg lim .; if lim=='' then lim=99; aLim=abs(lim)
parse var lim . hm. hf. Js Fs Ms; hm.0=0; hf.0=1
do j=0 to Alim; ff=F(j); mm=M(j)
Js=Js jW(j); Fs=Fs jw(ff); Ms=Ms jW(mm)
end
do j=0 to Alim; ff=F(j); mm=M(j)
Js=Js jW(j); Fs=Fs jw(ff); Ms=Ms jW(mm)
end
if lim>0 then say 'Js=' Js; else say 'J('aLim")=" word(Js,aLim+1)
if lim>0 then say 'Fs=' Fs; else say 'F('aLim")=" word(Fs,aLim+1)
if lim>0 then say 'Ms=' Ms; else say 'M('aLim")=" word(Ms,aLim+1)
exit /*stick a fork in it, we're done.*/
/*─────────────────────────────────────F, M, Jw subroutines────────────*/
F: procedure expose hm. hf.; arg n; if hf.n=='' then hf.n=n-M(F(n-1)); return hf.n
M: procedure expose hm. hf.; arg n; if hm.n=='' then hm.n=n-F(M(n-1)); return hm.n
Jw: return right(arg(1),length(lim)) /*right justifies # for nice look*/
/*──────────────────────────────────one─liner subroutines──────────────────────────────*/
F: procedure expose hm. hf.; parse arg n; if hf.n=='' then hf.n=n-M(F(n-1)); return hf.n
M: procedure expose hm. hf.; parse arg n; if hm.n=='' then hm.n=n-F(M(n-1)); return hm.n
Jw: return right(arg(1),length(lim)) /*right justifies # for nice look*/