awkcode.txt

c programming pearls answer

info ' countries
info.ans awk '
info.ans BEGIN { FS = "\t"; pat = ARGV[1]; ARGV[1] = "-" }
info.ans $1 ~ pat {
info.ans     printf("%s:\n", $1)
info.ans     printf("\t%d million people\n", $3)
info.ans     printf("\t%.3f million sq. mi.\n", $2/1000)
info.ans     printf("\t%.1f people per sq. mi.\n", 1000*$3/$2)
info.ans }
info.ans ' "$1" <countries
info1.ans awk '
info1.ans BEGIN { FS = "\t" }
info1.ans $1 ~ pat {
info1.ans     printf("%s:\n", $1)
info1.ans     printf("\t%d million people\n", $3)
info1.ans     printf("\t%.3f million sq. mi.\n", $2/1000)
info1.ans     printf("\t%.1f people per sq. mi.\n", 1000*$3/$2)
info1.ans }
info1.ans ' pat="$1" <countries
letter.text Subject: Demographic Information About #1
letter.text From: AWK Demographics, Inc.
letter.text 
letter.text In response to your request for information about #1,
letter.text our latest research has revealed that its population is #2
letter.text million people and its area is #3 million square miles.
letter.text This gives #1 a population density of #4 people per
letter.text square mile.
form.gen # form.gen - generate form letters
form.gen #   input:  prototype file letter.text; data lines
form.gen #   output: one form letter per data line
form.gen 
form.gen BEGIN {
form.gen     FS = ":"
form.gen     while (getline <"letter.text" > 0) # read form letter
form.gen         form[++n] = $0
form.gen }
form.gen 
form.gen {   for (i = 1; i <= n; i++) { # read data lines
form.gen         temp = form[i]         # each line generates a letter
form.gen         for (j = 1; j <= NF; j++)
form.gen             gsub("#" j, $j, temp)
form.gen         print temp
form.gen     }
form.gen }
capitals USSR	Moscow
capitals Canada	Ottawa
capitals China	Beijing
capitals USA	Washington
capitals Brazil	Brasilia
capitals India	New Delhi
capitals Mexico	Mexico City
capitals France	Paris
capitals Japan	Tokyo
capitals Germany	Bonn
capitals England	London
merge.awk awk ' BEGIN { FS = "\t" }
merge.awk       FILENAME == "capitals" {
merge.awk           cap[$1] = $2
merge.awk       }
merge.awk       FILENAME == "countries" && $4 == "Asia" {
merge.awk           print $1, $3, cap[$1]
merge.awk       }
merge.awk ' capitals countries
join.awk # join - join file1 file2 on first field
join.awk #   input:  two sorted files, tab-separated fields
join.awk #   output: natural join of lines with common first field
join.awk 
join.awk BEGIN {
join.awk     OFS = sep = "\t"
join.awk     file2 = ARGV[2]
join.awk     ARGV[2] = ""  # read file1 implicitly, file2 explicitly
join.awk     eofstat = 1   # end of file status for file2
join.awk     if ((ng = getgroup()) <= 0)
join.awk         exit      # file2 is empty
join.awk }
join.awk 
join.awk {   while (prefix($0) > prefix(gp[1]))
join.awk         if ((ng = getgroup()) <= 0)
join.awk             exit  # file2 exhausted
join.awk     if (prefix($0) == prefix(gp[1]))  # 1st attributes in file1
join.awk         for (i = 1; i <= ng; i++)     #     and file2 match
join.awk             print $0, suffix(gp[i])   # print joined line
join.awk }
join.awk 
join.awk function getgroup() { # put equal prefix group into gp[1..ng]
join.awk     if (getone(file2, gp, 1) <= 0)    # end of file
join.awk         return 0
join.awk     for (ng = 2; getone(file2, gp, ng) > 0; ng++)
join.awk         if (prefix(gp[ng]) != prefix(gp[1])) {
join.awk             unget(gp[ng])    # went too far
join.awk             return ng-1
join.awk         }
join.awk     return ng-1
join.awk }
join.awk 
join.awk function getone(f, gp, n) {  # get next line in gp[n]
join.awk     if (eofstat <= 0) # eof or error has occurred
join.awk         return 0
join.awk     if (ungot) {      # return lookahead line if it exists
join.awk         gp[n] = ungotline
join.awk         ungot = 0
join.awk         return 1
join.awk     }
join.awk     return eofstat = (getline gp[n] <f)
join.awk }
join.awk 
join.awk function unget(s)  { ungotline = s; ungot = 1 }
join.awk function prefix(s) { return substr(s, 1, index(s, sep) - 1) }
join.awk function suffix(s) { return substr(s, index(s, sep) + 1) }
relfile countries:
relfile 	country
relfile 	area
relfile 	population
relfile 	continent
relfile capitals:
relfile 	country
relfile 	capital
relfile cc:
relfile 	country
relfile 	area
relfile 	population
relfile 	continent
relfile 	capital
relfile 	!sort countries >temp.countries
relfile 	!sort capitals >temp.capitals
relfile 	!join temp.countries temp.capitals >cc
avgarea.awk { area += $area }; END { print area/NR }
qawk # qawk - awk relational database query processor
qawk 
qawk BEGIN { readrel("relfile") }
qawk /./   { doquery($0) }
qawk 
qawk function readrel(f) {
qawk     while (getline <f > 0)   # parse relfile
qawk         if ($0 ~ /^[A-Za-z]+ *:/) {     # name:
qawk             gsub(/[^A-Za-z]+/, "", $0)  # remove all but name
qawk             relname[++nrel] = $0
qawk         } else if ($0 ~ /^[ \t]*!/)     # !command...
qawk             cmd[nrel, ++ncmd[nrel]] = substr($0,index($0,"!")+1)
qawk         else if ($0 ~ /^[ \t]*[A-Za-z]+[ \t]*$/)  # attribute
qawk             attr[nrel, $1] = ++nattr[nrel]
qawk         else if ($0 !~ /^[ \t]*$/)      # not white space
qawk             print "bad line in relfile:", $0
qawk }
qawk function doquery(s,   i,j) {
qawk     for (i in qattr)  # clean up for next query
qawk         delete qattr[i]
qawk     query = s    # put $names in query into qattr, without $
qawk     while (match(s, /\$[A-Za-z]+/)) {
qawk         qattr[substr(s, RSTART+1, RLENGTH-1)] = 1
qawk         s = substr(s, RSTART+RLENGTH+1)
qawk     }
qawk     for (i = 1; i <= nrel && !subset(qattr, attr, i); ) 
qawk         i++
qawk     if (i > nrel)     # didn't find a table with all attributes
qawk         missing(qattr)
qawk     else {            # table i contains attributes in query
qawk         for (j in qattr)   # create awk program
qawk             gsub("\\$" j, "$" attr[i,j], query)
qawk         for (j = 1; j <= ncmd[i]; j++)  # create table i
qawk             if (system(cmd[i, j]) != 0) {
qawk                 print "command failed, query skipped\n", cmd[i,j]
qawk                 return
qawk            }
qawk         awkcmd = sprintf("awk -F'\t' '%s' %s", query, relname[i])
qawk         printf("query: %s\n", awkcmd)   # for debugging
qawk         system(awkcmd)
qawk     }
qawk }
qawk function subset(q, a, r,   i) {  # is q a subset of a[r]?
qawk     for (i in q)
qawk         if (!((r,i) in a))
qawk             return 0
qawk     return 1
qawk }
qawk function missing(x,     i) {
qawk     print "no table contains all of the following attributes:"
qawk     for (i in x)
qawk         print i
qawk }
qawk1.ans # qawk - awk relational database query processor
qawk1.ans 
qawk1.ans BEGIN { readrel("relfile") }
qawk1.ans /./   { doquery($0) }
qawk1.ans 
qawk1.ans function readrel(f) {
qawk1.ans     while (getline <f > 0)   # parse relfile
qawk1.ans         if ($0 ~ /^[A-Za-z]+ *:/) {     # name:
qawk1.ans             gsub(/[^A-Za-z]+/, "", $0)  # remove all but name
qawk1.ans             relname[++nrel] = $0
qawk1.ans         } else if ($0 ~ /^[ \t]*!/)     # !command...
qawk1.ans             cmd[nrel, ++ncmd[nrel]] = substr($0,index($0,"!")+1)
qawk1.ans         else if ($0 ~ /^[ \t]*[A-Za-z]+[ \t]*$/)  # attribute
qawk1.ans             attr[nrel, $1] = ++nattr[nrel]
qawk1.ans         else if ($0 !~ /^[ \t]*$/)      # not white space
qawk1.ans             print "bad line in relfile:", $0
qawk1.ans }
qawk1.ans function doquery(s,   i,j,x) {
qawk1.ans     for (i in qattr)  # clean up for next query
qawk1.ans         delete qattr[i]
qawk1.ans     query = s    # put $names in query into qattr, without $
qawk1.ans     while (match(s, /\$[A-Za-z]+/)) {
qawk1.ans         qattr[substr(s, RSTART+1, RLENGTH-1)] = 1
qawk1.ans         s = substr(s, RSTART+RLENGTH+1)
qawk1.ans     }
qawk1.ans     for (i = 1; i <= nrel && !subset(qattr, attr, i); ) 
qawk1.ans         i++
qawk1.ans     if (i > nrel)     # didn't find a table with all attributes
qawk1.ans         missing(qattr)
qawk1.ans     else {            # table i contains attributes in query
qawk1.ans         for (j in qattr)   # create awk program
qawk1.ans             gsub("\\$" j, "$" attr[i,j], query)
qawk1.ans         if (!exists[i] && ncmd[i] > 0) {
qawk1.ans             for (j = 1; j <= ncmd[i]; j++)
qawk1.ans                 x = x cmd[i, j] "\n"
qawk1.ans             print "executing\n" x  # for debugging
qawk1.ans             if (system(x) != 0) { # create table i
qawk1.ans                     print "command failed, query skipped\n", x
qawk1.ans                     return
qawk1.ans                }
qawk1.ans             exists[i]++
qawk1.ans         }
qawk1.ans         awkcmd = sprintf("awk -F'\t' '%s' %s", query, relname[i])
qawk1.ans         printf("query: %s\n", awkcmd)   # for debugging
qawk1.ans         system(awkcmd)
qawk1.ans     }
qawk1.ans }
qawk1.ans function subset(q, a, r,   i) {  # is q a subset of a[r]?
qawk1.ans     for (i in q)
qawk1.ans         if (!((r,i) in a))
qawk1.ans             return 0
qawk1.ans     return 1
qawk1.ans }
qawk1.ans function missing(x,     i) {
qawk1.ans     print "no table contains all of the following attributes:"
qawk1.ans     for (i in x)
qawk1.ans         print i
qawk1.ans }
randint # randint - return random integer x, 1 <= x <= n
randint 
randint function randint(n) {
randint     return int(n * rand()) + 1
randint }
randlet # randlet - generate random lower-case letter
randlet 
randlet function randlet() {
randlet     return substr("abcdefghijklmnopqrstuvwxyz", randint(26), 1)
randlet }
choose # choose - print in order k random elements from A[1]..A[n]
choose 
choose function choose(A, k, n,    i) {
choose     for (i = 1; n > 0; i++)
choose         if (rand() < k/n--) {
choose             print A[i]
choose             k--
choose         }
choose }
comb.ans # print k distinct random integers between 1 and n
comb.ans 
comb.ans { random($1, $2) }
comb.ans 
comb.ans function random(k, n,    A, i, r) {
comb.ans     for (i = n-k+1; i <= n; i++)
comb.ans         ((r = randint(i)) in A) ? A[i] : A[r]
comb.ans     for (i in A)
comb.ans         print i
comb.ans }
comb.ans 
comb.ans function randint(n) { return int(n*rand())+1 }
bridge.ans # bridge - generate random bridge hands
bridge.ans 
bridge.ans BEGIN { split(permute(52,52), deck)           # generate a random deck
bridge.ans         sort(1,13); sort(14,26); sort(27,39); sort(40,52) # sort hands
bridge.ans         prhands()                    # format and print the four hands
bridge.ans }
bridge.ans 
bridge.ans function permute(k, n,    i, p, r) {   # generate a random permutation
bridge.ans     srand(); p = " "                   # of k integers between 1 and n
bridge.ans     for (i = n-k+1; i <= n; i++)
bridge.ans         if (p ~ " " (r = int(i*rand())+1) " " )
bridge.ans             sub(" " r " ", " " r " " i " ", p)    # put i after r in p
bridge.ans         else p = " " r p                     # put r at beginning of p
bridge.ans     return p
bridge.ans }
bridge.ans 
bridge.ans function sort(left,right,    i,j,t) { # sort hand in deck[left..right]
bridge.ans     for (i = left+1; i <= right; i++)
bridge.ans         for (j = i; j > left && deck[j-1] < deck[j]; j--) {
bridge.ans             t = deck[j-1]; deck[j-1] = deck[j]; deck[j] = t
bridge.ans         }
bridge.ans }
bridge.ans 
bridge.ans function prhands() {                            # print the four hands
bridge.ans     b = sprintf("%20s", " "); b40 = sprintf("%40s", " ")
bridge.ans     card = 1                                  # global index into deck
bridge.ans     suits(13); print b "   NORTH"
bridge.ans     print b spds; print b hrts; print b dnds; print b clbs
bridge.ans     suits(26)  # create the west hand from deck[14..26]
bridge.ans     ws = spds substr(b40, 1, 40 - length(spds))
bridge.ans     wh = hrts substr(b40, 1, 40 - length(hrts))
bridge.ans     wd = dnds substr(b40, 1, 40 - length(dnds))
bridge.ans     wc = clbs substr(b40, 1, 40 - length(clbs))
bridge.ans     suits(39); print "   WEST" sprintf("%36s", " ") "EAST"
bridge.ans     print ws spds; print wh hrts; print wd dnds; print wc clbs
bridge.ans     suits(52); print b "   SOUTH"
bridge.ans     print b spds; print b hrts; print b dnds; print b clbs
bridge.ans }
bridge.ans 
bridge.ans function suits(j) {           # collect suits of hand in deck[j-12..j]
bridge.ans     for (spds = "S:"; deck[card] > 39 && card <= j; card++)
bridge.ans         spds = spds " " fvcard(deck[card])
bridge.ans     for (hrts = "H:"; deck[card] > 26 && card <= j; card++)
bridge.ans         hrts = hrts " " fvcard(deck[card])
bridge.ans     for (dnds = "D:"; deck[card] > 13 && card <= j; card++)
bridge.ans         dnds = dnds " " fvcard(deck[card])
bridge.ans     for (clbs = "C:"; card <= j; card++)
bridge.ans         clbs = clbs " " fvcard(deck[card])
bridge.ans }
bridge.ans 
bridge.ans function fvcard(i) {                    # compute face value of card i
bridge.ans     if (i % 13 == 0) return "A"
bridge.ans     else if (i % 13 == 12) return "K"
bridge.ans     else if (i % 13 == 11) return "Q"
bridge.ans     else if (i % 13 == 10) return "J"
bridge.ans     else return (i % 13) + 1
bridge.ans }
cliche # cliche - generate an endless stream of cliches
cliche #     input:  lines of form subject:predicate
cliche #     output: lines of random subject and random predicate
cliche 
cliche BEGIN { FS = ":" }
cliche       { x[NR] = $1; y[NR] = $2 }
cliche END   { for (;;) print x[randint(NR)], y[randint(NR)] }
cliche 
cliche function randint(n) { return int(n * rand()) + 1 }
grammar Sentence -> Nounphrase Verbphrase
grammar Nounphrase -> the boy
grammar Nounphrase -> the girl
grammar Verbphrase -> Verb Modlist Adverb
grammar Verb -> runs
grammar Verb -> walks
grammar Modlist ->
grammar Modlist -> very Modlist
grammar Adverb -> quickly
grammar Adverb -> slowly
sentgen # sentgen - random sentence generator
sentgen #   input:  grammar file; sequence of nonterminals
sentgen #   output: a random sentence for each nonterminal
sentgen 
sentgen BEGIN {  # read rules from grammar file
sentgen     while (getline < "grammar" > 0)
sentgen         if ($2 == "->") {
sentgen             i = ++lhs[$1]              # count lhs
sentgen             rhscnt[$1, i] = NF-2       # how many in rhs
sentgen             for (j = 3; j <= NF; j++)  # record them
sentgen                rhslist[$1, i, j-2] = $j
sentgen         } else
sentgen             print "illegal production: " $0
sentgen }
sentgen 
sentgen {   if ($1 in lhs) {  # nonterminal to expand
sentgen         gen($1)
sentgen         printf("\n")
sentgen     } else 
sentgen         print "unknown nonterminal: " $0   
sentgen }
sentgen