{"id":3772,"date":"2018-02-20T23:50:30","date_gmt":"2018-02-20T23:50:30","guid":{"rendered":"http:\/\/essaysparlor.com\/non-printable-characters\/"},"modified":"2017-02-20T18:38:58","modified_gmt":"2017-02-20T18:38:58","slug":"non-printable-characters","status":"publish","type":"post","link":"https:\/\/www.benedictsol.com\/blogs\/non-printable-characters\/","title":{"rendered":"Non-printable characters"},"content":{"rendered":"

\nCOMP 2103X1 Assignment 2
\nGeneral information about assignments (important!):
\nhttp:\/\/cs.acadiau.ca\/~jdiamond\/comp2103\/assignments\/General-info.html
\nInformation on passing in assignments:
\nhttp:\/\/cs.acadiau.ca\/~jdiamond\/comp2103\/assignments\/Pass-in-info.html
\nInformation on coding style:
\nhttp:\/\/cs.acadiau.ca\/~jdiamond\/comp2103\/assignments\/C-coding-style-notes
\n[1] A filter program is a program which reads its input from ?standard input? (?stdin?) and writes
\nits output to ?standard output? (?stdout?). Filter programs are useful because they make it easy
\nto combine the functions they provide to solve more complex problems using the standard shell
\nfacilities. Filter programs are also nice to write, because the programmer doesn?t have to worry
\nabout writing code to open and close files, nor does the programmer have to worry about dealing
\nwith related error conditions. In some respects, filter programs are truly ?win-win?.
\nWrite a filter program which uses getchar() to read in characters from stdin, continuing until
\nend of file (read the man page and\/or textbook to see the details on getchar(), or, heaven forbid,
\nreview the class slides). Your program must count the number of occurrences of each character in
\nthe input. After having read all of the input, it outputs a table similar to the one below which, for
\neach character seen at least once, lists the total number of times that character was seen as well as
\nits relative frequency (expressed as a percentage). Note that the characters n, r, t, \u0000, a, b,
\nf, and v (see man ascii) must be displayed with the appropriate ?escape sequence?. Ordinary
\nprintable characters must be output as themselves. Non-printable characters (see man isprint)
\nmust be printed with their three-digit octal code (see man printf).
\nYou can get input into a filter program (a2p1 in this case) in three ways:
\n(a) ?pipe? data from another program into it, like
\n$ echo blah blah | a2p1
\n(b) ?redirect? the contents of a file into the program, like
\n$ a2p1 < some-file
\n(c) type at the keyboard, and (eventually) type ^D (control-d) at the beginning of a line to
\nsignify end of file.
\nYour output must look like the following, for this sample case:
\n$ echo ^Aboo | a2p1
\nChar Count Frequency
\n————————–
\n001 1 20.00%
\nn 1 20.00%
\nb 1 20.00%
\no 2 40.00%
\nNote: in the above examples, and from now on in this course?s assignments, text in red is text that
\nthe human types, and a ?$” at the beginning of a line like that represents the shell prompt.
\n1
\nNote that I entered a ^A (control-a, not the circumflex character followed by the capital A) by
\ntyping ^V^A. The ^V tells your shell that you want it to interpret the next character literally, rather
\nthan to use any special meaning (during command line entry) that the next character might normally
\nhave. (Question: what does your shell do, when typing in a command line, if you type ^A without
\nfirst entering ^V? Try it and see if you can figure it out. You might find it useful to know this, and
\nto know what ^E and ^W do as well.)
\nYou should run your program on a few different inputs to demonstrate to the marker that you have
\nthought about (and programmed for!) the different cases that could occur. If you redirect input
\nfrom a data file, rather than using ?cat? to display the contents of your file when creating your
\ntranscript file, use a command like $ od -bc test-data-1 .
\n[2] The printf() function in C is very powerful and convenient, but it takes some getting used to.
\nThis question will give you experience with this function.
\nWhen you are testing functions like printf() which produce formatted output, sometimes you
\nwant to make sure that the spaces in the output are the ones you expect. To make it obvious where
\nall the white space came from, it is often convenient to enclose a format specification inside a pair
\nof characters that are not otherwise used in that output. For example, if you use something like
\nprintf(“|%f|n”, x)
\nthen you will know whether the %f format specification produced any spaces before the newline.
\nThe constant M_PI, an approximation to the value of \u0019, is defined in the system include file math.h.
\nWrite a program which prints out the value of M_PI using each of the following specifications, one
\nspecification per line of output:
\n(a) fixed point notation, field width of 9, 5 digits of precision, left justified
\n(b) fixed point notation, field width of 9, 5 digits of precision, right justified
\n(c) fixed point notation, field width of 9, no precision specification, right justified
\n(d) fixed point notation, field width unspecified, 5 digits of precision, right justified
\n(e) scientific notation, field width 9, 5 digits of precision, right justified
\n(f) scientific notation, field width 9, 5 digits of precision, left justified
\n(g) scientific notation, field width 14, 5 digits of precision, right justified
\n(h) scientific notation, field width 14, 5 digits of precision, left justified
\nAs an example of what your output might look like, here is one sample line of output:
\n|3.14159 | is field 9, precision 5, left justified
\nExamine your output and try to understand what the printf() function is doing, especially any
\noutputs that you find surprising.
\n2
\n[3] These days, many people are very concerned with the protection of private information. This
\nprogram will do a very rudimentary form of encryption. (Don?t use this for anything you want to
\nkeep secret!)
\nWrite a filter program to encrypt standard input as follows:
\n(i) upper case letters between ?A? and ?M? are replaced with the lower case letter 13 positions
\nfurther along in the alphabet (e.g., ?B? is replaced with ?o?);
\n(ii) upper case letters between ?N? and ?Z? are replaced with the lower case letter 13 positions
\nearlier in the alphabet (e.g., ?Z? is replaced with ?m?);
\n(iii) lower case letters between ?a? and ?m? are replaced with the upper case letter 13 positions
\nfurther along in the alphabet (e.g., ?d? is replaced with ?Q?);
\n(iv) lower case letters between ?n? and ?z? are replaced with the upper case letter 13 positions
\nearlier in the alphabet (e.g., ?y? is replaced with ?L?);
\n(v) the four punctuation characters ?.?, ?,?, ?!? and ??? are replaced with, respectively, ?!?, ???, ?.?
\nand ?,?.
\nOf course, an encryption program is no use without a corresponding decryption program. A bit of
\nthought (or experimentation) should show that this program will decrypt its own output.
\nTo test your program, create a few text files; some small, some big. Then run some tests which will
\nconvince the marker of the following things:
\n(i) the output of the program looks different than the input; and
\n(ii) running the output of the program through the program a second time recovers the original
\ndata.
\nYou can make use of the Unix utilities diff and\/or cmp, as well as cat, to help convince the
\nmarker that your program works. Here is a sample run with a small number of tests. Note that you
\ndon?t need to cat big files into the script file, but you can use ls -l or wc to show the marker
\nthat the files were big.
\n$
\n$
\n$ cat test1.dat
\nThis is a short file.
\nIs it long enough, or should it be longer?
\n$
\n$ a3p1 < test1.dat
\ngUVF VF N FUBEG SVYR!
\nvF VG YBAT RABHTU? BE FUBHYQ VG OR YBATRE,
\n$
\n$ a3p1 < test1.dat | a3p1
\nThis is a short file.
\nIs it long enough, or should it be longer?
\n$
\n$ wc test2.dat
\n1241 3394 44616 test2.dat
\n$ a3p1 < test2.dat > test2.dat.crypt
\n3
\n$
\n$ wc test2.dat.crypt
\n1241 3394 44616 test2.dat.crypt
\n$
\n$ cmp test2.dat test2.dat.crypt
\ntest2.dat test2.dat.crypt differ: byte 3, line 1
\n$
\n$ a3p1 < test2.dat.crypt > test2.dat.crypt.decrypt
\n$
\n$ cmp test2.dat test2.dat.crypt.decrypt
\n$
\nNotice that, as is common for Unix programs, cmp says nothing in the ?success? case, which for
\ncmp is when the two files are identical.
\nThe third (red) command entered above is interesting. It shows how the Unix shell (command
\ninterpreter) allows you to send the output of one program (the first a2p3) into the input to another
\nprogram (in this case the second a2p3). This is an extremely powerful feature of the shell,
\nespecially since your program does not have to do anything special to make this happen; as far as
\nyour program is concerned, it is reading from standard input and writing to standard output. The
\nfact that those may be the keyboard, screen, a file or another program generally don?t matter to
\nyour program. (In fact, the occasional program does care, but that is an uncommon circumstance.)
\nIn the partial script above I showed a test with a short file, and a long file. I showed that (some)
\nletters got encrypted as they should, and that punctuation is properly encrypted. I also showed that
\nmy program works with a fairly long file, but you might want to try a bigger file yet. And you
\nmight consider using the head program to output just the first few lines of a very long file to your
\nscript file.
\nShould anything else be tested? Are there any boundary cases here?
\nDid you use functions in any of these questions? Should you have? Did you document them
\ncorrectly?
\nDoes you program ?blow up? on unexpected input, or does it deal with bad input in a ?graceful?
\nway?
\nHow does your program deal with boundary conditions, if there are any?
\nDid you remember to put all required comments in? Does your program call out for any other
\ncomments in the body of the code?<\/p>\n

<\/p>\n","protected":false},"excerpt":{"rendered":"

COMP 2103X1 Assignment 2 General information about assignments (important!): http:\/\/cs.acadiau.ca\/~jdiamond\/comp2103\/assignments\/General-info.html Information on passing in assignments: http:\/\/cs.acadiau.ca\/~jdiamond\/comp2103\/assignments\/Pass-in-info.html Information on coding style: http:\/\/cs.acadiau.ca\/~jdiamond\/comp2103\/assignments\/C-coding-style-notes [1] A filter program is a program which reads its input from ?standard input? (?stdin?) and writes its output Read More …<\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[],"tags":[],"class_list":["post-3772","post","type-post","status-publish","format-standard","hentry"],"_links":{"self":[{"href":"https:\/\/www.benedictsol.com\/blogs\/wp-json\/wp\/v2\/posts\/3772","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.benedictsol.com\/blogs\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.benedictsol.com\/blogs\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.benedictsol.com\/blogs\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.benedictsol.com\/blogs\/wp-json\/wp\/v2\/comments?post=3772"}],"version-history":[{"count":0,"href":"https:\/\/www.benedictsol.com\/blogs\/wp-json\/wp\/v2\/posts\/3772\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.benedictsol.com\/blogs\/wp-json\/wp\/v2\/media?parent=3772"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.benedictsol.com\/blogs\/wp-json\/wp\/v2\/categories?post=3772"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.benedictsol.com\/blogs\/wp-json\/wp\/v2\/tags?post=3772"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}