i tried searching bash for functions that can be used but can't really find anyThe entire system is always in a loop.
That would depends on how the script calls itself. I would argue it is possible to do so without considered as recursion.
Otherwise any loops would be recursion since it is repeatedly running a same set of codes right ?
Here the exclusion of recursion is within the programming language construct, get it ?
exec[[ $1 > 0 ]] && exec -c $0 $(($1 - 1)) "$1\n$2" || echo -ne "$2"[[ $1 -ge 0 ]] && N=${2:-0} M=${3:-1} && read S < <(echo "$M + $N" | bc) && echo $N && exec -c $0 $(($1 - 1)) $S $N $Mexec works. It basically just load an executable image file into the same process and start executing it, analogous wipe out everything in the memory and reload again. The flexible part is the means to pass information from one iteration into another via the parameters. If you look at the entire script, you can simply formulate it as a function where the script parameters are the function parameters.bc output when the number is really large.
How did you learn these advanced Bash tecniques?The answer is understanding Unix Programming. The feature you ought to be looking for isexec
The technique was originally evolved from the earlier counting question. You have used brace expansion, and this is mine
Bash:[[ $1 > 0 ]] && exec -c $0 $(($1 - 1)) "$1\n$2" || echo -ne "$2"
The Fibonacci solution is evolved from it too.
Bash:[[ $1 -ge 0 ]] && N=${2:-0} M=${3:-1} && read S < <(echo "$M + $N" | bc) && echo $N && exec -c $0 $(($1 - 1)) $S $N $M
Why is it not recursion ? If you know howexecworks. It basically just load an executable image file into the same process and start executing it, analogous wipe out everything in the memory and reload again. The flexible part is the means to pass information from one iteration into another via the parameters. If you look at the entire script, you can simply formulate it as a function where the script parameters are the function parameters.
Hence there you go, a solution to loop without really using any bash looping construct nor recursion. It will also work eternally as long as the computer is running since it wouldn't be consuming more and more memory extensively.
There are some issues with your code and also I'm not sure why you want to use that formula since the question is not asking you to compute one particular term but all the terms from start to end. Just dynamic programming will do. You will also want to take a look at what happens tobcoutput when the number is really large.
Hope you have fun.
TL;DR
exec command is found in a lot of programming languages, but be careful what you are reading. Quite a few languages don't exhibit the real exec that is happening on a Unix system. In an Unix OS course, you will learn fork() and exec() in C. Here is a tutorial on it https://ece.uwaterloo.ca/~dwharder/icsrts/Tutorials/fork_exec/exec but they all does the same thing. Reload the specified image into the current process. We do that in Unix C because it often follows a fork process. Fork is the Unix way of creating new processes from the current process. These new processes are children process with their parent process set as the current one. This is also the start of multiprocessing.$ lsls and totally replace the forked process of bash. All these knowledge comes from understanding Unix programming.while true; do ls; done >/dev/null$ while true; do pstree | egrep -B 2 '\bls\b' | grep -v grep; echo ------------------------------------; done
| |-+= 01790 root login -fp davidktw
| | \-+= 01792 davidktw -bash
| | \--= 83082 davidktw (ls)
------------------------------------
| |-+= 01790 root login -fp davidktw
| | \-+= 01792 davidktw -bash
| | \--= 83109 davidktw (ls)
------------------------------------
| |-+= 01790 root login -fp davidktw
| | \-+= 01792 davidktw -bash
| | \--= 83135 davidktw (ls)
------------------------------------
------------------------------------
| |-+= 01790 root login -fp davidktw
| | \-+= 01792 davidktw -bash
| | \--= 83188 davidktw (ls)
------------------------------------ls command parent is the bash shell, and despite the ls command process id is changing all the time, the shell process id (01792) never change.
Your Unix programming skills are too advanced. I am still deciphering different parts of your bash scriptTL;DR
I don't strive to simply complete my work, I strive to perfect my craft.
When you do that, you wouldn't be satisfy with just able to solve the problem. You will ask if there are any other better ways to do the same thing ? What is the pros and cons, caveats and quirks and workarounds you need to deal with for each solutions. That's how you improve more than just the work assigned to you. Real industrial works are good starting ground, but often they are limited by time, resources and cost. If you want to investigate further, you need to further complicate the problem. You need to look beyond the problem and investigate. That's how to improve significantly.
Honestly speaking, what I have demonstrate in this Bash challenge is nothing difficult. All the skill set requires is what is required of a Unix software engineer.execcommand is found in a lot of programming languages, but be careful what you are reading. Quite a few languages don't exhibit the realexecthat is happening on a Unix system. In an Unix OS course, you will learnfork()andexec()in C. Here is a tutorial on it https://ece.uwaterloo.ca/~dwharder/icsrts/Tutorials/fork_exec/
There are quite a few variants ofexecbut they all does the same thing. Reload the specified image into the current process. We do that in Unix C because it often follows a fork process. Fork is the Unix way of creating new processes from the current process. These new processes are children process with their parent process set as the current one. This is also the start of multiprocessing.
Just this simplistic shell code would have already demonstrated the above.
Bash:$ ls
The current shell is first forked to create child process, then the child process run an exec command to load the binary image oflsand totally replace the forked process ofbash. All these knowledge comes from understanding Unix programming.
Here is a demonstration. In one terminal, I was running this
Code:while true; do ls; done >/dev/null
In another terminal, I am running this
Code:$ while true; do pstree | egrep -B 2 '\bls\b' | grep -v grep; echo ------------------------------------; done | |-+= 01790 root login -fp davidktw | | \-+= 01792 davidktw -bash | | \--= 83082 davidktw (ls) ------------------------------------ | |-+= 01790 root login -fp davidktw | | \-+= 01792 davidktw -bash | | \--= 83109 davidktw (ls) ------------------------------------ | |-+= 01790 root login -fp davidktw | | \-+= 01792 davidktw -bash | | \--= 83135 davidktw (ls) ------------------------------------ ------------------------------------ | |-+= 01790 root login -fp davidktw | | \-+= 01792 davidktw -bash | | \--= 83188 davidktw (ls) ------------------------------------
Notice thelscommand parent is thebashshell, and despite the ls command process id is changing all the time, the shell process id (01792) never change.
The Fibonacci demonstration is just leveraging on the dynamic programming solution of it. You can of course do it for a lot of other programming solutions, but it is not meant for actual use, because you will almost never want to write your code the way for the challenge, and rather just use a simple loop construct to complete it. I am just creating constraint to force into the usage of this technique.
If you feel this is difficult, would the 2 Quicksort techniques that I have written in another thread be any easier for you ?
Feel free to read them at https://forums.hardwarezone.com.sg/...odes-to-share-for-fun.6832706/#post-144837640
There are 2 techniques I have demonstrated, one is functional, the other is imperative and faster.
Too bad shell cannot use multithreading, which is not the same as multiprocessing. I do hope you understand the differences, because it will allow me to easily parallelise the quicksort in an efficient manner.
I hope you have also tried on the challenge questions. I set them for anyone whom is keen to learn.
Just keep doing it. I get to somewhere because I don't stop doing what I like.Your Unix programming skills are too advanced. I am still deciphering different parts of your bash script
exec command that I just shared with you.
For challengers who want to test themselves, try it but without using "exec"
Using trap and env. Why not
But have you observe the memory consumption and how long it will run before something happens ?
Your method will work in the following manner. Inelegant but works
#!/usr/bin/env bash
TMPFILE=`mktemp -u`
mkfifo $TMPFILE
(
trap 'sleep 0; kill -USR1 $$' USR1
# read <&2 # this works, but a keypress will disturb it
read <$TMPFILE
) &
C=$!
sleep 0
trap 'I=$(($I+1)); echo $I; sleep 0; [[ $I -lt $M ]] && kill -USR1 $C || exit' USR1
trap 'rm -f $TMPFILE; kill -9 $C' EXIT
I=0
M=${1:-10}
[[ $M -gt 0 ]] && kill -USR1 $C || exit
# read <&2 # this works, but a keypress will disturb it
read <$TMPFILE$ ./countrap.sh 0
$ ./countrap.sh 1
1
$ ./countrap.sh 10
1
2
3
4
5
6
7
8
9
10
$ ./countrap.sh 20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20Impressive. Some very interesting techniques shown hereYour method will work in the following manner. Inelegant but works
Bash:#!/usr/bin/env bash TMPFILE=`mktemp -u` mkfifo $TMPFILE ( trap 'sleep 0; kill -USR1 $$' USR1 # read <&2 # this works, but a keypress will disturb it read <$TMPFILE ) & C=$! sleep 0 trap 'I=$(($I+1)); echo $I; sleep 0; [[ $I -lt $M ]] && kill -USR1 $C || exit' USR1 trap 'rm -f $TMPFILE; kill -9 $C' EXIT I=0 M=${1:-10} [[ $M -gt 0 ]] && kill -USR1 $C || exit # read <&2 # this works, but a keypress will disturb it read <$TMPFILE
Code:$ ./countrap.sh 0 $ ./countrap.sh 1 1 $ ./countrap.sh 10 1 2 3 4 5 6 7 8 9 10 $ ./countrap.sh 20 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Have fun
Most programmers just end up as doers. This is a humble opinion too. E=mc^2 may be short and readable, but most don't know enough of what it means.Ever seen a mechanic moan and groan about a car that is designed without any thought for a maintenance mechanic. A mechanic has craw underneath vs open the bonnet in order to change the alternator. The same goes to programming. The coder has to be mindful of some dude who will be doing the maintenance or enhancement work in the future. Cryptic code under the disguise of efficiency or readability? I bet most programmer would prefer the latter in my humble opinion.
For Mazda 3, need to go underneath, and Toyota Vios from the top.Most programmers just end up as doers. This is a humble opinion too. E=mc^2 may be short and readable, but most don't know enough of what it means.
There are mechanics that design cars because of how much they know about cars, they don't necessarily has to crawl under the car.
Sure, tell that to the designer that design the cars.
But we don't have access to these designers which the same as maintenance coders do not have access to davidktw. My uni mate was telling me that some Wall Street big shot is ditching perl for python. Cryptic code can cause pain to those coders doing the migration work.Sure, tell that to the designer that design the cars.
That's why I said most programmers are doers. You can choose to fit in, or surpass. It's your choice. You don't need access to me, you just need access to your inner-self.
You will agree with me on this statement ?That's why I said most programmers are doers. You can choose to fit in, or surpass. It's your choice. You don't need access to me, you just need access to your inner-self.
一念之差
