首页 > > 详细

Shell Scripts辅导、Unix / Linux讲解、c/c++辅导、讲解C/C++编程 调试Matlab程序|讲解数据库SQL

Shell Scripts Page 1
Shell Scripts LABORATORY TWO
OBJECTIVES
1. Processes in Unix / Linux
2. Common Shell Commands
3. Basic Shell Script Programming
4. File Transfer Protocol
5. Web Pages Publishing
Working from Home
You would often have a need to work at home and want to have access to Linux and Unix (those running
Mac OS/X will have your access to a Unix already – Mac OS/X is built on top of a variant of Unix).
When you are at home, you have to use ssh or putty to connect to machines in Department of
Computing. The departmental machines are protected against arbitrary direct access from outside PolyU.
That will provide better protection against hackers. To connect to a machine in the department, say,
apollo, you need to connect first to the gateway machine, called csdoor. Once you are in csdoor, you
could connect to other machines in the department.
To connect from home, execute ssh 12345678d@csdoor.comp.polyu.edu.hk
Type your password and answer yes when you are prompted about the RSA key fingerprint
After logging in to csdoor, type the name of the machine to connect to, for example, apollo
You now enter your password to login the machine
If you do not have ssh installed on your PC, you could download, install and then execute putty from
http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html followed
by typing csdoor.comp.polyu.edu.hk as hostname. Select port 22 and connection type SSH.
After you have logged in to csdoor, you could also type load to check for the loading of the list of
available machines before you decide to select a machine with fewer users to connect to. There are
currently two accessible Linux machines, namely, apollo and apollo2. Mac machines are running Unix.
Processes in Unix / Linux
In Unix / Linux, one or more processes will be created when executing programs using the shell. The set
of processes existing in the system could be viewed by means of the ps command. For example, you
could type the command ps -elf to see a list of processes. Each process is identified by a process id
or simply pid. Most processes in the system would be in “S” state (suspended) under the the “S” or
“STAT” column. The process executing ps is itself in “R” state (running). There could be several
processes in this “R” state, when there are multiple CPUs with the machine, like apollo2. You may
monitor the list of processes currently executing in the machine, by the command top. You should be
seeing many more processes on apollo2, inclusive of other students’ processes.
If you find that a particular process may have fallen into an infinite loop, you could attempt to terminate
that process by killing it. You will use the kill command, by supplying the process ID, which can be
seen when you type the command ps -elf for the list of processes, e.g., to terminate process 12345,
type kill 12345 and if you still cannot kill it, use the stronger option kill -9 12345
The invocation of a program is called a job or a task in Unix / Linux. A job normally creates one
process, but could also create multiple processes to complete the mission. For example, the commonly
used pipe or “|” operator in shell generates multiple processes. For example, type ls –l | more and Shell Scripts Page 2
you can use ps to check that there are two processes created, one for ls -l and the other for more.
The ls and more commands are executed together for a job. In this case, you have to use another shell
(e.g., use another ssh client) to check because you could not type the ps command when the ls and
more commands are still being executed. We could try a sequence of commands for a job like ps;
pwd; cal 2019. Processes belonging to the same job form a process group.
You could use multiple ssh clients when you are using the computers in the laboratory so that each
program you want to execute can be run on different windows (ssh or putty sessions). However, if
you are connecting from home, you may have only one terminal or only one connection to Linux. Then
could we execute multiple jobs together? Luckily, the answer is yes, and it works with C-shell (csh)
and Bourne-again shell (bash). The default shell on apollo running a variant of Linux called CentOS
and on most Mac machines running OS/X is bash (version 4.2 for apollo and version 3.2 for Mac).
At any moment, there is only one process group derived from one job that is connected to the keyboard
for input, but there could be multiple jobs not connected to the keyboard running at the same time. We
say that these multiple jobs, except for the one currently connected to the keyboard, are being run in
background. The one connected to the keyboard is running in foreground. All these multiple background
processes could still produce outputs to the screen, and all the outputs from all the jobs will be
intermixed together. To put a job to background, use the “&” operator when you run the job.
Alternatively, to put an already running job to the background, you will first type “-Z” to stop
the job and then type bg to put it to the background. To put a specific background job to the foreground,
use fg command with the job number.
Try running the long printing program lab2A.c three times with different inputs simultaneously and you
could see an intermixed output. Type ps –lf to see your processes (perhaps using another window).
cc lab2A.c –o lab2A
./lab2A first 50 &
./lab2A second 60 &
./lab2A third 40 &
Repeat the above execution of the three processes on three different windows (terminals). Now we do
not need to use “&” operator. All processes can receive inputs from the keyboard and produce outputs to
the appropriate windows. Ability to switch jobs between background and foreground via bg and fg will
be useful when you do not have the luxury of multiple windows but have to do multiple tasks, for
example, when you are connecting from remote PC at home via one connection.
Do you find that the lines are intermixed together to make it very difficult to type in the new command
when a single window is used? To relieve the problem, you could create a script to contain all the
commands. For example, you could create a (script) file called allLab2 to contain the following lines:
./lab2A first 50 &
./lab2A second 60 &
./lab2A third 40 &
You should normally type chmod 700 allLab2 to make the script file allLab2 executable. You
can then execute the jobs by typing allLab2. The effect is just like typing the three lines on the
keyboard by yourself, like a batch file.
Here is a list of common commands used with processes.
Command Usage Description
ps ps -ef Show the processes in the computer
kill kill %2
kill 4321
kill -9 4321
Terminate a background job
Terminate a process
Terminate a process more forcefully
bg bg Move a stopped foreground job to background
fg fg %2 Move background job number 2 to foreground
jobs jobs Show the list of background jobsShell Scripts Page 3
time time a.out Show the total execution time of a program and its share of CPU time
uptime uptime Show the current workload of the computer, e.g., number of users
top top Show the CPU and resource utilization of the computer with a list of
active processes
More Shell Commands and Variables
Sometimes, users will try to customize their Linux system to look like whatever system they are familiar
with, by changing the meaning of commands or create new commands. Recall that this is achieved via
the use of alias, e.g., make ls behave like what you like by setting an alias for the command, alias
ls=’ls –l’, or use the more familiar command dir via alias dir=ls. If you want to define
many aliases at the same time, you may put them into a “batch” file and execute it (like .bat file in
MS-DOS). Then you do not need to type in the alias commands every time you login the system. Just
place all your aliases into a file, e.g., myalias. You can then execute this file containing useful aliases
by typing source myalias. You are encouraged to create your own alias file to customize your
Linux. Note that you can also execute allLab2 above via the source command, i.e., source
allLab2. The file does not need to be changed to executable via chmod if source command is used.
In Unix / Linux, you could know more about the hardware platform that you are using with the uname
command. Try out uname –a on apollo2 and/or another machine (perhaps even a Mac). You can know
the full name of your machine by hostname. Recall that pwd returns the current path where you are
working. Connecting these together with the whoami and pwd commands, you can change the
command prompt easily. In bash, the command prompt is defined within the variable PS1. Type echo
$PS1 and see the information about the format.
echo $PS1
On apollo, you would see something like \u \h:${PWD}$. Here \u means the user name (which can
be retrieved by whoami), \h means the machine name (a full version can be retrieved by hostname),
${PWD} evaluates the variable PWD in the current shell. This variable contains the current (present)
working directory in full (which can be retrieved by the command pwd). On a Mac, you would see
\h:\W \u\$, where \W means the current directory.
You may want to make the prompt like
Mickey@apollo2:
you could type
export PS1=”Mickey@\h: ”
To make the prompt like
(/home/12345678d) 12345678dyou
could type
export PS1=”($PWD) $(whoami)- ”
To make the prompt like
Linux@apollo2 [30]:
where 30 is the current command number, you could type
export PS1=”$(uname)@\h [\!]:”
Many Unix / Linux functions are defined based on system variables, which are called shell variables.
Here, PS1 is a shell variable that directs Linux shell to display its content as the (primary) prompt. There
are two types of shell variables, namely, global variables and local variables in bash and csh. A global
variable is called an environment variable. An environment variable can be created via the export
command in bash, converting a local variable into a global variable. Once created, the environment
variable can be accessed and modified (using =) in the regular manner. You can also remove the
environment variable by the unexport command. You would need to use the command setenvShell Scripts Page 4
instead of set to modify an environment variable in csh. The concept of environment variables is
useful, since their contents can be accessed by a C or Java program to serve their purpose, e.g. knowing
who is running the program. Recall that we have made use of a special variable called PATH in Lab 1,
by executing export PATH=”$PATH:.”. This command has the effect of inserting the current
directory “.” at the end of the current value stored in the variable PATH. Unix / Linux will then treat this
as the search path for any command to be executed.
When you type ls -l, you will see the permission mode for your files, the first one indicates whether it
is a directory (where d means a directory and - means a file, and it is also used to indicate special
system-related privileges), the first part for yourself, the second part for users in the same group, and the
third part for all other users. For each part, the privileges refer to read, write and execute respectively.
Note that the rest of this paragraph is valid for standard Unix / Linux systems in many other institutes
and for your personal web page (/webhome/12345678d/public_html). This standard access
permission arrangement is also valid under /tmp, but it is more dangerous to try at /tmp, since
everybody logging onto the same machine (apollo or apollo2) will be accessing and sharing the SAME
/tmp. You might ignore this part if you just use the departmental file system, but it is still useful to
learn about the general Unix / Linux file system settings. In Unix / Linux systems, you better change the
permission mode for your home directory from the default drwx--x--x (everyone can “execute”
your directory, i.e., can access its content) or even worse drwxr-xr-x (everyone can see the files and
access the content) to drwx------ (no one else could access), with chmod 700
/webhome/12345678d. Here the parameter for chmod is expressed in Octal (base 8), one octet for
each part, so that 7 means rwx and 5 means r-x.
If you use the departmental file system, you will almost always see drwx------ for any directory and
-rwx------ for any file. Only the write privilege can be set currently. Thus, performing chmod 644
or chmod 600 or chmod 777 will not have created change. If you perform chmod 000, you could
get –r-x------ for a file. Changes in local desktop files would not be carried back to the file system.
The First Shell Script
Try to run the following first shell script program in bash, call it firstscript.sh. Just type the
script name to execute it, after setting via chmod 700. Note that you may need to make some changes
to the program text before it can be executed, if you merely copy it from the pdf file. Watch out for
difference in quotation symbols and for ^M characters when you make the copy, before you try to run it.
This is one of the major reasons that a seemingly correct shell script program cannot run properly on the
actual machine. You can use the command dos2unix available on most Unix and Linux systems to
perform removal of those ^M characters for file firstscript.sh:
dos2unix firstscript.sh
The dos2unix command is not available in Mac OS/X, but you can still do the same trick using the
following approach, by creating a new file called firstscript2.sh:
tr –d ’\r’ < firstscript.sh > firstscript2.sh
#!/bin/bash
echo Hello $USER, time is $(date)
# $(date) allows the COMMAND/PROGRAM date to be executed and replacing the output
echo -n ”You must be ”
# -n keeps output on the same line and we need a space at the end
whoami
# whoami is a command/program
echo Your home is $HOME
# HOME is a variable
echo Your calendar for this month is:
cal # cal is a program
echo Friends on this computer $(hostname) are:
who # who and hostname are programs
echo ”Thanks for coming. See you soon!!”Shell Scripts Page 5
Basic Shell Script Programming
Try out the shell script programs covered / to be covered in the lecture and follow through the statements
/ commands to understand how they work. Try the programs using different inputs. The symbol * is a
wildcard character that leads to the matching of filenames, etc.
#!/bin/bash
# There is a bug here, could you debug it?
read -p ”What was your score? ” score
echo You get a score of $score
# [ ... ] is for testing condition on an expression
# use gt > / ge >= / lt < / le <= / eq = / ne != for comparison, use –a and –o for and/or
if [ $score -ge 85 -a $score -le 100 ]; then
echo You got an A grade!
else if [ $score -ge 70 ]; then
echo You got a B grade
else
echo You better study!!
fi
fi
# a second way to express this
# use && and || to connect multiple testing expressions
if [ $score -ge 85 ] && [ $score -le 100 ]; then
echo You got an A grade!
elif [ $score -ge 70 ]; then
# elif is like else if, but using else if needs one more matching fi at the end
echo You got a B grade
else
echo You better study!!
fi
#!/bin/bash
# Try also using the notion of ;;& instead of ;; in some of them (works on apollo/apollo2)
read -p ”Which subject have you performed worst? ” code
case $code in
comp1*) echo ”$code is just a level 1 subject.” ;;
comp2*) echo ”$code is an intermediate level 2 subject.” ;;
comp[34]*) echo ”$code is a challenging senior level subject.” ;;
comp[56]*) echo ”$code is too advanced for you.” ;;
comp*) echo ”$code is unrecognized in comp.” ;;
*) echo ”$code is not a valid code.” ;;
esac
#!/bin/bash
# Is there any potential bug in the first for loop?
courselist=(1011 2021 2432)
for course in ${courselist[*]}; do
if [ $course -lt 2000 ]; then
echo level 1 course $course
else echo level 2 course $course
fi
done
# try list created by command (here it is ls)
for file in `ls`; do
echo file $file exists
done
# try list expanded from wildcard match (all C programs)
for f in *.c; do
echo $f is a C file
done
# try list expanded from a range
for i in {1..10}; do
echo i is $i
done
# try list expanded from a range of non-consecutive numbers
for i in {1..20..3}; do
echo i is $i
done
# try a C-style loop, need to use the syntax of (( ... ))
for ((i=1; i<=10; i++)); do
echo number is $i
done
# try handling input argument listShell Scripts Page 6
for item; do # absence of list implies the input argument list
echo one of the arguments is $item
done
#!/bin/bash
# Could you convert it to compute the factorial?
read -p ”Please enter a number: ” num
ctr=1 sum=0
while [ $ctr -le $num ]; do
sum=$((sum + ctr)) # same as let sum=sum+ctr
echo $ctr
let ctr++ # same as ctr=$((ctr+1))
done
echo ”The sum of $num numbers is $sum.”
#!/bin/bash
# Compare with the program based on while loop
read -p ”Please enter a number: ” num
ctr=1 sum=0
until [ $ctr -gt $num ]; do
sum=$((sum + ctr))
echo $ctr
let ctr++
done
echo ”The sum of $num numbers is $sum.”
#!/bin/bash
# Note that if this does not work for some of you due to the current file system in PolyU.
# You may do this under your own /webhome/12345678d,
# or make use of /tmp, which would still work under apollo or apollo2.
# Note that /tmp is shared between everyone using the machine,
# so please create your own subdirectory:
# $ cd /tmp
# $ mkdir myid12345678d
# $ cd myid12345678d
# // copy some files to here then try
for f in *; do # for each file in the current directory
if [ -d $f ]; then
echo $f is a directory
fi
if [ -f $f -a -x $f ]; then
echo $f is a plain executable file
fi
if [ ! -w $f ]; then
echo $f could not be modified
fi
done
#!/bin/bash
# Call this script testarg and try out different situations
echo ”This script is called $0”
if [ $# -eq 0 ]; then
echo ”No argument”
else
echo ”The number of arguments : $#”
echo ”The first argument : $1”
echo ”The last argument : ${!#}” # this returns the last argument
echo ”The full list : $@”
echo ”The fifth argument : $5” # how would you check that this fifth argument exists?
fi
#!/bin/bash
# Call this script filecp and try out different situations
# filecp dummy lab2Z.c
# filecp lab2A.c dummy
# filecp lab2A.c dummy # copy again
# filecp lab2A.c dummy # copy again, after making dummy not modifiable
cp $1 $2
if [ $? -eq 0 ]; then
echo ”File copied successfully”
else
echo ”Fail to copy file”
fiShell Scripts Page 7
#!/bin/bash
# Call this script chain and try out different situations
# Example: chain whoami pwd
# Example: chain whoami abc
# Example: chain abc whoami
# Example: chain abc def
# where abc and def are not commands nor executable files
echo first command is $1
echo second command is $2
echo ”executing $1 && $2”
($1) && ($2)
echo ”executing $1 || $2”
($1) || ($2)
# Executing command chain inside a testing condition
if [[ `$1` && `$2` ]]; then
echo ”both are successful”
else
echo ”some are not successful”
fi
if [[ `$1` || `$2` ]]; then
echo ”some are successful”
else
echo ”both are not successful”
fi
#!/bin/bash
# This script takes on two arguments (numbers) M and N
echo ’This script computes sum(1..M) + sum(1..N)’
num1=$1 num2=$2 # $1 and $2 are for script
echo Input M and N: $num1 $num2
function sumof { # first M/N, second returned sum
local ctr=1 sum=0 # local variables
while [ $ctr -le $1 ]; do # $1 is for sumof
let sum=sum+ctr ctr++
done
eval $2=$sum # $2 is for sumof and return
}
sumof $num1 r1
sumof $num2 r2
echo ”Sum of $num1 and $num2 numbers is $((r1+r2))”
File Transfer Protocol
[Optional]
The File Transfer Protocol or FTP allows you to upload files from PC to
computer system (at an ISP or to Unix or Linux) or download files from
computer system to your PC. A popular program on the PCs is the
WS_FTP program implementing FTP. However, it is not very secure and
has been replaced by Secure File Transfer Program (SFTP) in the
department. You can download the freeware WinSCP offering SFTP from
http://winscp.net/eng/download.php and install it. You need
to fill in csdoor.comp.polyu.edu.hk as hostname and select port 22 when
connecting from home. An equivalent software for FTP on the Mac is
Cyberduck. You can invoke Cyberduck to transfer files around. Do not
forget to choose the more secure SFTP protocol instead of FTP.
Note that if you are sending plain text files via FTP, you should use text format (this will automatically
correct those ^M monsters on Unix/Linux created by an editor on PC so that you do not need to use the
dos2unix or tr command). For other files, you should use binary format to ensure the correctness of
non-printable characters and foreign language characters (e.g., Chinese characters). If you are not sure
about the nature of your files, it is much safer to send them using binary format. Binary files include
program executables, Word files, Excel files, images, etc.Shell Scripts Page 8
Publishing Web Pages via Unix / Linux
[Optional]
In Department of Computing, personal web pages accessible to the public are stored in Unix/Linux file
system. They must be placed under a special directory called public_html under your web home
directory (under your home directory in other normal Unix file systems). Directories must be at least
executable and files must be at least readable to other users. The default file accessed by web browsers
is index.html. Once you have created a set of web pages using Microsoft Expression Web or
Dreamweaver, you may try to publish them to the public. You have to upload those related files from
PC/Mac to Unix/Linux, perhaps using sftp / WinSCP or move them via J: drive. The web page files
must be stored under /webhome/12345678d/public_html. We must do some preparation work
to set the appropriate protection mode. Note: The preparation work only needs to be done once in
Unix/Linux. You may or may not need to set protection mode for your own directory in PolyU system,
but that is the default approach in most other Unix/Linux.
Change the protection mode of your own directory to drwx--x--x (i.e., 711) by typing
chmod 711 /webhome/12345678d
Create a sub-directory called public_html by typing
mkdir /webhome/12345678d/public_html
Change the protection mode of the directory to drwx—-x--x (i.e., 711) by typing
chmod 711 /webhome/12345678d/public_html
Now, invoke sftp or WinSCP to upload to Unix/Linux or copy the files to J: by yourself.
The files are now placed in Unix/Linux. There is one major subtle difference between PC and
Unix/Linux. In Unix/Linux, all web pages have file names ending with .html but in PC, all web pages
have file names ending with .htm. Depending on the web server, you may need to rename the file(s):
mv index.htm index.html
Now, you can explore your web pages using any browser. Your own homepage can be viewed at
http://www.comp.polyu.edu.hk/~12345678d
where 12345678d should be replaced by your own username. You may need to make some
adjustments to the contents of those web page files if you discover some minor problems, such as path
names. Also, you need to make sure that files for web pages are readable (chmod 644) and directories
are at least executable (chmod 711). It is now that the pico editor becomes useful when you need to
touch up in the file contents. However, you need to work directly with the “terrible” HTML formats. To
simplify, you may use zip to archive all the necessary files created with web tools into a zip file and
place it under Unix/Linux. For your information, Unix/Linux people often use the tar command to
archive files. Finally, you can extract the files from the zip file and set the appropriate protection mode
for files and directories.Shell Scripts Page 9
Laboratory Exercise
Write a bash shell script called euro to input the scores of UEFA Champions League group stage
matches and draw up the league tables for the teams. The 32 teams are divided into 8 groups, each group
with 4 teams. The winner of a match will be awarded 3 points, the loser 0 point. In case of a draw, both
teams will be awarded 1 point. Your program then reads in a sequence of files containing the scores of
matches in different rounds, as indicated by the prefix of those files as the parameter. The outputs should
be divided into the groups, ranked by points. Your program should work on any set of valid inputs, not
necessarily on the real-life inputs derived from the scores of actual matches.
The actual tie-breaking rules in Champions League are very complicated, inclusive of head-to-head
results, away goals, minor league for multi-way ties, and even up to red and yellow cards (disciplinary
points). We will be adopting a much simplified set of tie-breaking rules. If there is a tie, the first tie
breaker is by goal difference, then by number of goals scored, finally by team name. For example,
Liverpool will still rank before Napoli if Napoli were to draw 2:2 with RedStar in the first
match instead of 0:0. InterMilan will rank before Tottenham if InterMilan were to beat PSV
by 5:4 instead of 2:1 in the second match. Note that if the actual Champions League tie-breaking rules
were adopted, Tottenham would always be ahead of InterMilan, regardless of whether
InterMilan beated PSV by 2:1, or 5:4, or even 6:5, since Tottenham would be ahead based on
away goals for the two head-to-head matches. You could test the correctness of your program by
changing the scores in the input files.
In a properly formed schedule, each team in each group will face each other exactly twice, one at home
and one away. You can assume that there is no error in the information contained in each file. In other
words, you do not need to handle errors in the score files.
For instance, the program can be run like:
euro score18
Here, score18 is the prefix of the files containing the match scores, e.g. score18Rount1,
score18Round2. Each line of the score file contains the score of a match. The first element is the
group name, followed by the first team, the goals scored and then the second team. The first team is the
home team and the second team is the visiting team. For simplicity, you can assume that there is no
space in the team name. You may consider using the back quote operator in a for-loop to extract all
information. Typical file contents are shown below:
Filename Content
score18Round1 Group B Barcelona 4 0 PSV
Group B InterMilan 2 1 Tottenham
Group A Brugge 0 1 Dortmund
Group D Schalke 1 1 Porto
Group A Monaco 1 2 Madrid
Group C Liverpool 3 2 PSG
Group C RedStar 0 0 Napoli
Group D Galatasaray 3 0 LokoMotiv
Group E Ajax 3 0 AEK
Group F Shakhtar 2 2 Hoffenheim
Group G RealMadrid 3 0 Roma
Group H Valencia 0 2 Juventus
Group E Benfica 0 2 Bayern
Group G Plzen 2 2 CSKA
Group F ManCity 1 2 Lyon
Group H YoungBoys 0 3 ManUnited
score18Round2 Group F Hoffenheim 1 2 ManCity
Group H Juventus 3 0 YoungBoys
Group E AEK 2 3 Benfica
Group G CSKA 1 0 RealMadrid
Group E Bayern 1 1 AjaxShell Scripts Page 10
Group H ManUnited 0 0 Valencia
Group F Lyon 2 2 Shakhtar
Group G Roma 5 0 Plzen
Group C PSG 6 1 RedStar
Group D LokoMotiv 0 1 Schalke
Group C Napoli 1 0 Liverpool
Group D Porto 1 0 Galatasaray
Group B PSV 1 2 InterMilan
Group A Dortmund 3 0 Monaco
Group B Tottenham 2 4 Barcelona
Group A Madrid 3 1 Brugge
score18Round3 Group E AEK 0 2 Bayern
Group H YoungBoys 1 1 Valencia
. . .
The output of your program should look like, after processing upon all the files in this season (formatting
is not important):
Group A
Team W D L Point GoalF GoalA GoalD
Dortmund 4 1 1 13 10 2 8
AtlMadrid 4 1 1 13 9 6 3
Brugge 1 3 1 6 6 5 1
Monaco 0 1 5 1 2 14 -12
Group B
Team W D L Point GoalF GoalA GoalD
Barcelona 4 2 0 14 14 5 9
Tottenham 2 2 2 8 9 10 -1
InterMilan 2 2 2 8 6 7 -1
PSV 0 2 4 2 6 13 -7
Group C
Team W D L Point GoalF GoalA GoalD
PSG 3 2 1 11 17 9 8
Liverpool 3 0 3 9 9 7 2
Napoli 2 3 1 9 7 5 2
RedStar 1 1 4 4 5 -17 -12
. . .
Group H
Team W D L Point GoalF GoalA GoalD
Juventus 4 0 2 12 9 4 5
ManUnited 3 1 2 10 7 4 3
Valencia 2 2 2 8 6 6 0
YoungBoys 1 1 4 4 4 12 -8
Requirements:
1. Elementary level: your script can read in the match scores from one file and display the number of
goals-for and goals-against for teams correctly.
2. Basic level: your script can read in the match scores from all files and compute the number of wins,
draws and losses, as well as goals-for, goals-against and goal differences for teams in the group tables
correctly.
3. Required level: your script can produce the correct sorted output with information correctly computed.
4. Bonus level: your script can group the teams together without having to rely on the group name in the
file (e.g. assuming that all group names were changed to “Z”). Of course, the names and the ordering of
the eight groups will become unspecified in this case. To be more adventurous, you might also try to
implement the actual tie-breaking rules adopted by the UEFA Champions League, assuming that you
would not need to use the red and yellow card information for final tie-breaking.
Name your program euro and submit it via BlackBoard on or before 15 February 2019.

联系我们 - QQ: 99515681 微信:codinghelp
程序辅导网!