IdList = identifier ^ ","This form can also be used to model a construct representing one or more $A$’s, rather than using $A^+$ or $AA^{*}$ or $A^{*}A$. Show how to do this.
Program = Block
Block = (Stmt ";")+
Stmt = Id "=" Exp
| "read" Id ("," Id)*
| "write" Exp ("," Exp)*
| "while" BoolExp "loop" Block "end"
Exp = Exp1 ([+-] Exp1)*
Exp1 = Exp2 ([*/] Exp2)*
Exp2 = "-"? Exp3
Exp3 = INTLIT | ID | "(" Exp ")"
BoolExp = BoolExp1 ("or" BoolExp1)*
BoolExp1 = BoolExp2 ("and" BoolExp2)*
BoolExp2 = Exp (("<" | "<=" | "==" | "!=" | ">=" | ">") Exp)?
| BoolExp3
BoolExp3 = "not"? BoolExp4
BoolExp4 = "true" | "false" | "(" BoolExp ")"
-- and go to the end of the line. Perhaps because of this, the designers
decided not to make the unary negation operator have the highest precedence. Instead, expressions are defined as follows:
Exp = Exp1 ("and" Exp1)* | Exp1 ("or" Exp1)*
Exp1 = Exp2 (relop Exp2)?
Exp2 = "-"? Exp3 (addop Exp3)*
Exp3 = Exp4 (mulop Exp4)*
Exp4 = Exp5 ("**" Exp5)? | "not" Exp5 | "abs" Exp5
Explain why this choice was (probably) made. Also, give an abstract syntax tree for the expression -8 * 5 and explain how this is similar to and how it is different from the alternative of dropping the negation from Exp2 and adding - Exp5 to Exp4.
elsif keyword in Perl, Ruby, and Ada. (The reason is the same for all three languages.) Then propose changes to these languages’ syntax that preserve the syntactic prevention on the dangling-else, but avoids the funny word. Hint: you only have to change the syntax clause for the if-statement; you do not have to add any new clauses.
3[467]|5[97]|365
(a = 3) >= m >= ! & 4 * ~ 6 || y %= 7 ^ 6 & p
if x > 2 or not F(F(X)) then
Put (-3 * Q);
elsif not Here or There then
loop
while Close loop Try_Harder; end loop;
X := X ** 3 mod 2*X;
end loop;
Q.all(4).G(6) := Person.List(2);
else
raise Hell;
end if;
int f(int x, int y) {
return y,x?a.p[5]+=7&!y<x<y+++x||+x|*&y-~--y*x^y:0;
}
printf("%08X %#16.7e\n",x---a.p[9]^x|*&p&1,*((float*)&x));
die and split are both list operators):
die "\n">>1,~\$$x^split @a,3|x**$;=>%p&&&p;
sub f {
print $x[0] unless q/pig =~ m!^r$!/ =~ m!^\((4)+!x;
push @_, sort reverse keys %$shift, g A 1, 2
}
Program = (Decl ";")* Exp
Decl = val ID "=" Exp
| fun ID "(" Params? ")" "=" Exp
Exp = NUMLIT | ID | uop Exp | Exp bop Exp
| Exp "?" Exp ":" Exp | ID "(" Args? ")" | "(" Exp ")"
Params = ID ("," ID)*
Args = Exp ("," Exp)*
uop = "-" | "abs" | "not"
bop = "+" | "-" | "*" | "/" | "mod" | "and" | "or" | "==" | "<"
fun gcd(x, y) = y == 0 ? x : gcd(y, x mod y)unless, if,
while, and until operators, which are non-associative.
A and B and C, one may not write A and B or C.
<, <=, ==,
!=, >=, and >), which are
non-associative.
<<
and >>)
*, /,
and %)
+ and -)
**)
- and not are prefix, while ! (for factorial) is postfix.
Because these are non-associative, one cannot write - - 2 or
-5! or 3!!!.
[e1 .. e2] for expressions
e1 and e2), function calls, and of course, parenthesized
expressions.
Assume the existence of tokens ID, NUMLIT, STRINGLIT, and CALL.
EXP ::= EXP1 (('if' | 'while' | 'unless' | 'until') EXP1)?
EXP1 ::= EXP2 ('and' EXP2)* | EXP2 ('or' EXP2)*
EXP2 ::= EXP3 (RELOP EXP3)?
EXP3 ::= EXP4 (SHIFTOP EXP4)*
EXP4 ::= EXP5 (ADDOP EXP5)*
EXP5 ::= EXP6 (MULOP EXP6)*
EXP6 ::= EXP7 ('**' EXP6)?
EXP7 ::= ('-' | 'not')? EXP8
EXP8 ::= EXP9 '!'?
EXP9 ::= ID | NUMLIT | STRINGLIT | CALL | '(' EXP ')' | '[' EXP '..' EXP ']'
(* 2 3 4 5) evaluates
to 120, and (– 16 9 4) evaluates to 3. Show that
parentheses are necessary to disambiguate arithmetic
expressions in Lisp (in other words, give an example of an
expression whose meaning is unclear when parentheses are removed).
Why then, does the author Michael L. Scott say in his book that “Issues of
precedence and associativity do not arise with prefix or postfix
notation?” Reword this claim to make explicit the hidden
assumption.
. to an identifier which is not a field of the
record (or struct) in Ada.
for I in A'Range loop Put("*"); X := X+1; end loop; (Ada).
{int x; int x;}
{int x; {int x;}}
{int x; struct x {};}
void f() {return 5;}
x +. 2;
x = (((int)x)-*0);
x---!-+~*&x
x = (((int)x)-5));
x>&x
if (x == 2) {return 1;}; else {return 2;};
int a[5]; a[5]=10;
float y; double x = y / 0.0;
Hawai`i = 2;
int y = 0; *y = 7;
main(5, 0, 0, 0, 0, 0); /* a call to the usual main() function */
printf("%d\n", x, y, z);
class C {}
struct {int x;} p; p.y;
int f() {int* p = p;}
int main() {main();}
int f() {int p; return p;}
let val x = 2 val x = 3 in x end;
let val x = 5; val x = "dog" in x end;
let val x = print 5 in x end;
let val x = print "5" in x end;
let val y = ref 2; val x = while (!y < 1) do print "*" in x end;
let val y = ref 2; val x = while (!y != 1) do print "*" in x end;
let val x = 3 in () end;
let val p = *^$q in () end;
X, make it so that
X^ = X. If this is not possible, state why it is not possible.
X, make it so
that X.all = X. If this is not possible, state why it is not
possible.
P = P.all. If it is not possible to do so, state
why no such variable can be defined.
p == *p.
If it is not possible to do so, state why no such variable can be
defined.
(x += 7) *= z but you can't say this
in C. Explain the reason why, using precise, technical terminology.
See if this same phenomenon holds for conditional expressions, too.
What other languages behave like C++ in this respect?
A := (3)
gives a static semantic error when A is a one-element array of
Integer. Why is this so? Propose a (trivial) syntactic extension to
Ada that would remove this irritation.
X: Integer := X + 1; Foo: Foo; Bar: Real := Bar(Foo);(where global declarations of
X, Foo and Bar are visible) are
all illegal, since a declaration of an identifier hides global declarations of the same name immediately
at the point it appears in the text, but the identifier may not be used until its declaration is complete.
Give an alternate interpretation under which these declarations would be legal and explain the
advantages and disadvantages of it from both the programmer's and the compiler writer's perspectives.
public void fail() {
class Failure extends RuntimeException {}
throw new Failure();
}
declare x = 2;
sub f() {print x;}
sub g() {declare x = 5; f(); print x;}
g();
print x;
var x = 1
function f() {return x;}
function g() {var x = 2; return f();}
print g() + x
function g(h) {
var x = 2;
h()
}
function main() {
var x = 5
function f() {
print x + 3
}
g(f)
}
main()
function f(a) {
var x = a - 1
function g() {
print x - 17
}
h(g)
}
function h(p) {
var x = 13
p()
}
f(18)
null and undefined do not get coerced to objects,
and non-functions do not get coerced to functions. I would say it's roughly 90% weakly
typed. It’s not 100% weakly typed because its designer thought that coercing things
to functions and even objects would be going too far, since there is no consensus
on the obvious coercion to make.
Dog were a subclass
of class Animal, then objects of class Dog[] would be compatible
with the type Animal[]. Write a fragment of Java code that shows
that this means that Java is not completely statically typed.
Include in your answer a well-written explanation that shows
you truly understand the difference between static and dynamic
typing.
Dog and Rat are subclasses of Animal, this code
Animal[] pets = new Dog[4]; pets[0] = new Rat();compiles fine but when executed throws an
ArrayStoreException, that's
right, a run-time typecheck error. This means Java is NOT 100%
statically typed because this typecheck occurs at run time. A language
can only be called 100% statically typed if all type conflicts are
detected at compile time.
local
fun split [] = ([],[])
| split [h] = ([h], [])
| split (x::y::t) = let val (s1,s2) = split t in (x::s1,y::s2) end
fun merge c ([], x) = x
| merge c (x, []) = x
| merge c (h1::t1, h2::t2) =
if c(h1,h2)<0 then h1::merge c(t1,h2::t2) else h2::merge c(h1::t1,t2);
in
fun sort c [] = []
| sort c x = let val (p, q) = split x
in merge c(sort c p, sort c q)
end;
end;
c within sort
split
merge
y in the third clause of split?
sort and explain why it is not what you would
expect.
struct A {B* x; int y;};
struct B {A* x; int y;};
Suppose the rules for this language stated that this language used
structural equivalence for types. How would you feel if you were a
compiler and had to typecheck an expression in which an
A was used as a B? What problem might you run into?
struct {
int n;
char c;
} A[10][10];
If the address of A[0][0] is 1000 (decimal), what is the
address of A[3][7]?
double *a[n]; double (*b)[n]; double (*c[n])(); double (*d())[n];
double (*foo(double (*)(double, double[]), double)) (double, ...);Describe rigorously, in English, the type of foo.
while (true)
line := readLine();
if isAllBlanks(line) then exit end;
consumeLine(line);
end;
Show how you might accomplish the same task using a while or
repeat loop, if midtest loops were not available. (Hint: one
alternative duplicates part of the code;
another introduces a Boolean flag variable.) How do these
alternatives compare to the midtest version?
If in Java or C or
JavaScript, such that the call If(c, e1, e2) would return e1
if c evaluated to true, and e2 if it evaluated to false.
Show why, in these languages, such a function is absolutely not the same as
the conditional expression c?e1:e2. You can show a code fragment
that would return different results based on whether the function
were called versus the conditional expression were evaluated.
(p==null ? null : p.value) is null-safe, whereas
the call If(p==null, null, p.value) is not: it throws a NullPointerException
if p is null. A more blatant example can be seen in the difference between
(true ? 1 : formatMyHardDrive()) and
If(true, 1, formatMyHardDrive()).
int f(int x, char y);
void g(int x) {if (x < 0) f(2, 'c');}
int f(int x, char y) {g(randomInteger());}
In C++, when f is finally declared, the names
of the formal parameters don't have to be repeated exactly as they
appeared in the incomplete specification. But in Ada they do.
Explain why the Ada rule makes life much easier for the compiler
writer.
[a0, a1, ..., an-1]
and returns the list
[a0, f(a1), f(f(a2)),
f(f(f(a3))), ...].
For example, if you pass as arguments the function that
doubles its inputs, and the list [4, 3, 1, 2, 2], then
the return value would be [4, 6, 4, 16, 32].
Hint: Do the f(f(f...)) as a separate function. Also
you do not have to make your function tail recursive.
function ss(a) {
function s(i, acc) {
return i == a.length ? acc : s(i+1, a[i]*a[i]+acc)
}
return s(0, 0);
}
def ss(a)
s = Proc.new{|i,acc| i==a.length ? acc : s[i+1, a[i]*a[i]+acc]}
s[0, 0]
end
Given: a list [a0, a1, ..., an-1],
Return: a0*a1 + a2*a3
+ a4*a5 + ....
For example, if given [3, 5, 0, 28, 4, 7] we return
15 + 0 + 28 = 43. If there are an odd number of
elements in the list, assume there is an extra 1
for padding.
Here is, by the way, a non-tail-recursive formulation:
fun sum_of_prods [] = 0 | sum_of_prods (x::nil) = x | sum_of_prods (x::y::t) = x * y + sum_of_prods t;
eval, that accepts an
array of integers a, and a function f, and returns an array of
functions, each of which, when called, invokes f on the
corresponding element of a.
For example, if your function was called g, then calling
g([6,3,1,8,7,9], dog) would return an array of functions p
such that, for example, calling p[3]() would invoke dog(8).
function g(a, f) {
var b = [];
for (var i = 0; i < a.length; i++) {
b[i] = function(i){return function(){f(a[i])};}(i);
}
return b;
}
square and
addSix the obvious way, and we called this new method
weird, then:
[4, 6, 7, 3, 5, 2, 4].weird(addSix, square)would return the function
z such that
z(2) == 55because the element at index 2 within the array is 7 and $7^2 + 6 = 55$.
Weekdays := Day_Set(False, True, True, True, True, True, False);
we could construct the aggregate directly in the variable
Weekdays. Give an example of an assignment statement that
illustrates the necessity of constructing an aggregate in temporary
storage (before copying to the target variable).
AngleReader
which displays a picture of a circle and notifies all its listeners
of the angle, in degrees, that the mouse cursor makes with the horizontal
axis of the circle as the mouse moves over it.
val dot =
let
fun transpose ... =
in
....
end;
The transpose function should work like this
transpose ([x1,...,xn],[y1,..,yn]) = [(x1,y1),...,(xn,yn)]raising
Domain if the arrays have different lengths. The body
of the definition of dot (between the in and end) should
contain only instances of the functions transpose, o, foldr,
map, op*, op+, and the value 0.
x = 1;
y = [2, 3, 4];
function f(a, b) {b++; a = x + 1;}
f(y[x], x);
print x, y[0], y[1], y[2];
2 2 2 4.
y[1], and that becomes 2 + 1 = 3, so it prints
2 2 3 4.
b++ changes x immediately
so x becomes 2. Then, since a refers to the expression
{y[x]}, it will need to compute y[2] which is 3.
The script prints 2 2 3 3.
x = 1;
y = 2;
function f(a, b) {a = 3; print b, x;}
f(x, x + y);
print x;
void foo() {
int i;
printf("%d ", i++);
}
int main() {
int j;
for (j = 1; j <= 10; j++) foo();
}
Local variable i in subroutine foo is never initialized. On many systems, however,
the program will display repeatable behavior, printing 0 1 2 3 4 5 6 7 8
9. Suggest an explanation. Also explain why the behavior on other systems might
be different, or nondeterministic.
with Ada.Text_IO, Ada.Integer_Text_IO;
use Ada.Text_IO, Ada.Integer_Text_IO;
procedure P is
A: Integer := 4;
type T is access Integer;
B: T := new Integer'(4);
C: T := new Integer'(4);
procedure Q (X: in out Integer; Y: T; Z: in out T) is
begin
X := 5;
Y.all := 5;
Z.all := 5;
end Q;
begin
Q (A, B, C);
Put (A);
Put (B.all);
Put (C.all);
end P;
call foo(2)
print* 2
stop
end
subroutine foo(x)
x = x + 1
return
end
nextOdd. The first time
you call this subroutine you get the value 1. The next time, you get
a 3, then 5, then 7, and so on. Show a snippet of code that uses this
subroutine from outside the module. Is it possible to
make this module hack-proof? In other words, once you compile this module,
can you be sure that malicious code can't do something to disrupt the
sequence of values resulting from successive calls to this function?
Container:
template <class Item>
class Container {
public:
unsigned numberOfItems() {return currentSize;}
bool isEmpty() {return currentSize == 0;};
virtual void flush() = 0;
~Container() {flush();}
private:
unsigned currentSize;
};
Here the idea is that each particular (derived) container class shall
implement its own flush() operation (which makes sense because
different containers are flushed in different ways: there may be
arrays, linked lists, rings or hashtables used in the representation),
and when a container is destroyed its flush() operation will
be automatically invoked. However, the idea is flawed and the
code as written causes a terrible thing to happen. What happens?
Person and
subclasses for different jobs (e.g., programmer, manager,
ticket agent, flight attendant, supervisor, student, etc.)
is a lousy design. Give an alternative.
class Item {
private int id;
private static int numberOfItemsCreated = 0;
public Item() {id = numberOfItemsCreated++;}
// pretend that there are more members here...
};
As you can see, every item that gets created will get a unique id.
Because this pattern occurs frequently, it might be nice to generalize
this and make make something reusable out of it so we don't have to
write this code inside every class that needs ids. Perhaps we
need an interface or abstract class. Tell me why these two suggestions
won't work with a detailed, technical answer. Then tell me something
that will work. (Note: there is nothing wrong with the access
modifiers above; the problems with my two suggestions have to
do with the nature of interfaces and abstract classes.)
class C {protected: int x; ...};
C c;
then your job is to assign a new value to c.x.
Assume there are no public operations of C that
modify x that you know of. Also, do not use
any preprocessor tricks (like #define protected
public).
class C {int x;};
C c;
C* p = &c;
cout << p;
and there is no compile-time nor link time error, despite the
fact that operator<<(C*) is not a member of ostream
(since that class was declared before you declared C), nor for
that matter did anyone declare the global function
ostream& operator<<(ostream&, C*);
So why does it all work? Explain exactly what gets printed and why.
class Foo {
public int a;
public String b;
}
...
class Bar extends Foo {
public float c;
public int b;
}
Does the representation of a Bar object contain one b field or two?
If two, are both accessible, or only one? Under what circumstances?
Answer for C++, Java, Python, and Scala.
Foo is an abstract class in a C++ program, why is it
acceptable to declare variables of type Foo*, but not of
type Foo? Does this problem even make sense to ask in
Java or Python?
Put
procedure at the same time, their outputs may be interleaved. (This
could produce amusing and even distasteful results, e.g. writing
"sole" in parallel with "ash") Show how to set
things up so only one task is writing at a time.
if not T'Terminated then
T.E;
end if;
var countDown = function () {
var i = 10;
var update = function () {
document.getElementById("t").innerHTML = i;
if (i-- > 0) setTimeout(update, 1000);
}
update();
}
The second argues that this is better:
var countDown = function () {
var update = function (i) {
document.getElementById("t").innerHTML = i;
if (i-- > 0) setTimeout(function () {update(i)}, 1000);
}
update(10);
}
Your role is to figure out which programmer is right, if any. Make a fairly extensive list of
the pros and cons of each approach. Your list will be graded on completeness, neatness, correct usage
of terminology (don't forget to mention "anonymous function" and "closure"), and
how articulately you express yourself. Bad grammar will impact your grade negatively.
You may want to consider readability and (especially) performance.
>> strip_vowels("Hello, world")
=> "Hll, wrld"
>> scramble("Hello, world")
=> "w,dlroH elol"
>> powers_of_two(70) {|x| puts x}
1
2
4
8
16
32
64
=> nil
>> powers(3, 400) {|x| puts x}
1
3
9
27
81
243
=> nil
>> interleave(["a", "b"], [1, 2, true, nil]) => ["a", 1, "b", 2, true, nil]
>> [5,4,[3],9].stutter => [5,5,4,4,[3],[3],9,9]
$ ruby prefixes.rb matsumoto m ma mat mats matsu matsum matsumo matsumot matsumoto
$ ruby lines.rb states.txt 50
dog="spike"; class <<dog; def bark; "arf"; end; end; dog.bark
"arf", since we essentially gave this one
dog its own bark method, by attaching it to its own
singleton class.
class <<"sparky"; def bark; "woof"; end; end; "spraky".bark
class <<"sparky"; def bark; "woof"; end; end; "sparky".bark
dog="sparky"; class <<dog; def bark; "woof"; end; end; dog.bark
"woof", because we attached the bark method
to the object referenced by the variable dog, through
its metaclass.
class <<"sparky"; def bark; "woof"; end; end; "sparky".bark
NoMethodError because the object in whose
metaclass we added the bark method WAS NOT the same
string object we tried to call bark on.
class <<:sparky; def bark; "woof"; end; end; :sparky.bark
TypeError because Ruby does not allow metaclasses
on symbol objects. Maybe this is because Ruby treats
symbols in such a super-special way an never puts them
in the object pool. It probably holds them as plain
old small integers.class <<2; def bark; "woof"; end; end; 2.bark
TypeError for the same reason as for symbols.
class Counter attr_reader :val; @val = 0; def bump(); @val += 1; end end Counter.new.bump; Counter.new.val
def dot(a, b)
a.zip(b).map{|x,y| x*y}.inject{|x,y| x+y}
end
assert_equal(dot([], []), 0) and it failed because her
method returned nil, not 0.
def dot(a, b)
a.zip(b).inject(0){|x,y| x+y[0]*y[1]}
end
Eventually she wrote a unit test with the first array longer
than the second and got a TypeError. She fixed that by raising
an ArgumentError if the arguments to dot had different
lengths. Show her fixed up method.
def dot(a, b)
raise ArgumentError if a.length != b.length
a.zip(b).inject(0) {|x,y| x+y[0]*y[1]}
end
class Array
def *(a)
..............her code here..............
end
end
And the unit tests worked: [3,4,2] * [1,5,0] == 23 for example.
But this fancy * definition had a very nasty side effect,
which, if she did this in real production code, would have
probably broken something big time. What went down with
this definition?
* operator in the array class; any new definition replaces
the old one. Old code using Array * int and Array * string will break badly,
because ints and strings can’t be converted to arrays.
scala> change(96) res2: (Int, Int, Int, Int) = (3,2,0,1) scala> change(8) res3: (Int, Int, Int, Int) = (0,0,1,3)
scala> stripVowels("Hello, world")
res4: java.lang.String = Hll, wrld
def stripVowels(s: String) = {
"""[aeiouAEIOU]""".r.replaceAllIn(s, "")
}
scala> scramble("Hello, world")
res5: java.lang.String = w,dlroH elol
scala> powersOfTwo(70, (p:Int) => {println("I got a " + p)})
I got a 1
I got a 2
I got a 4
I got a 8
I got a 16
I got a 32
I got a 64
def powersOfTwo(limit: Int, callback: Int => Unit) = {
powers(2, limit, callback)
}
scala> powers(3, 400, (p:Int) => {println("I got a " + p)})
I got a 1
I got a 3
I got a 9
I got a 27
I got a 81
I got a 243
scala> interleave(List("a", "b"), List(1, 2, true, null))
res8: List[Any] = List(a, 1, b, 2, true, null)
scala> stutter(List(5,4,List(3),9)) res9: List[Any] = List(5, 5, 4, 4, List(3), List(3), 9, 9)
prefixes.scala) that writes successive prefixes
of its first input argument, one per line, starting with the first prefix, which is zero
characters long.
Assuming the string "matsumoto" were entered, the output would be:
$ scala prefixes.scala matsumoto m ma mat mats matsu matsum matsumo matsumot matsumoto
lines.scala) that reports the number of lines in the
file named by the first argument. For example, if the file states.txt has 50 lines:
$ scala lines.scala states.txt 50
flatten that takes a tree as
argument and returns an ordered list of its leaves.
Then we can say
def sameFringe(t1: Tree[Any], t2: Tree[Any]) = flatten(t1) == flatten(t2)
flatten in Scala.
sameFringe when
the trees differ in their first few leaves?
flatten so that sameFringe does not suffer from
the problem you identified in part (b).
m, s,
or y?
Blah
dog dog 123
Four
Zero
1234567890*
More stuff!
1234
Then you should return the hash reference {4=>3,11=>2,0=>1} because, before
the part in the file with two blank lines, there are three lines with
four characters, two lines with 11 characters, and 1 line with zero
characters. The lines after the two blank line sequence are
not considered, nor are the lines in the two blank line
sequence. If there is no place in the file with two blank lines,
then all lines will be counted.
class Pair implements Cloneable {
private Object first, second;
public Pair(Object x, Object y) {first = x; second = y;}
public getFirst() {return first;}
public getSecond() {return second;}
}
user=> (change 96) [3,2,0,1] user=> (change 8) [0,0,1,3]
user=> (stripVowels "Hello, world") "Hll, wrld""
user=> (scramble "Hello, world") "w,dlroH elol"
user=> (powersOfTwo 70 (fn [p] (println "I got a " p)) I got a 1 I got a 2 I got a 4 I got a 8 I got a 16 I got a 32 I got a 64
user=> (powers 3 400 (fn [p] (println "I got a " p)) I got a 1 I got a 3 I got a 9 I got a 27 I got a 81 I got a 243
user=> (interleave '("a" "b") '(1 2 true null))
("a" 1 "b" 2 true null)
user=> (stutter '(5 4 (3) 9)) (5 5 4 4 (3) (3) 9 9)
prefixes.clj) that writes successive prefixes
of its first input argument, one per line, starting with the first prefix, which is zero
characters long.
Assuming the string "matsumoto" were entered, the output would be:
$ java -cp clojure.jar clojure.main prefixes.clj matsumoto m ma mat mats matsu matsum matsumo matsumot matsumoto
lines.clj) that reports the number of
non-blank, non-commented
lines in the file named by the first argument. Blank lines are those that have either no characters or
consist entirely of whitespace; commented lines are those that begin with the "#" character.
For example, if the file states.txt has 50 non-blank, non commented lines:
$ java -cp clojure.jar clojure.main lines.clj states.txt 50
divmod built-in function.
>>> change(96) (3, 2, 0, 1) >>> change(8) (0, 0, 1, 3)
>>> strip_vowels("Hello, world")
"Hll, wrld"
>>> scramble("Hello, world")
"w,dlroH elol"
>>> for x in powers_of_two(70): print x 1 2 4 8 16 32 64
>>> for x in powers(3, 400): print x 1 3 9 27 81 243
>>> interleave(["a", "b"], [1, 2, True, None]) ["a", 1, "b", 2, True, None]
>>> stutter([5,4,[3],9]) [5,5,4,4,[3],[3],9,9]
$ python prefixes.py vanrossum v va van vanr vanro vanros vanross vanrossu vanrossum
#.
For example, if the file states.txt has 50 non-blank, non-comment lines:
$ python lines.py states.txt 50