Baseline: tree as shared
This commit is contained in:
commit
659c03bbf8
1471 files changed
+990535
No files matched your search
@@ -0,0 +1,26 @@
|
||||
// Numbers: every arithmetic operator, both numeric types, and the conversions between them.
|
||||
// EXPECT: 3.5
|
||||
// EXPECT: 3
|
||||
// EXPECT: 1
|
||||
// EXPECT: -4
|
||||
// EXPECT: 512
|
||||
// EXPECT: 2.0
|
||||
// EXPECT: 27
|
||||
// EXPECT: 28
|
||||
// EXPECT: 5
|
||||
// EXPECT: 7 -7 -7
|
||||
DECLARE A, B : INTEGER
|
||||
DECLARE X : FLOAT
|
||||
A <- 7
|
||||
B <- 2
|
||||
OUTPUT A / B
|
||||
OUTPUT A DIV B
|
||||
OUTPUT A MOD B
|
||||
OUTPUT -2 ^ 2
|
||||
OUTPUT 2 ^ 3 ^ 2
|
||||
OUTPUT 4 / 2
|
||||
X <- 27.54
|
||||
OUTPUT INT(X)
|
||||
OUTPUT ROUND(X)
|
||||
OUTPUT ABS(-5)
|
||||
OUTPUT 7 DIV 1, " ", -7 DIV 1, " ", (-7) DIV 1
|
||||
@@ -0,0 +1,11 @@
|
||||
// A FLOAT formula with a FUNCTION; classic first program in any language.
|
||||
// EXPECT: 212.0
|
||||
// EXPECT: 37.0
|
||||
FUNCTION TO_FAHRENHEIT(C : FLOAT) RETURNS FLOAT
|
||||
RETURN C * 9 / 5 + 32
|
||||
ENDFUNCTION
|
||||
FUNCTION TO_CELSIUS(F : FLOAT) RETURNS FLOAT
|
||||
RETURN (F - 32) * 5 / 9
|
||||
ENDFUNCTION
|
||||
OUTPUT TO_FAHRENHEIT(100.0)
|
||||
OUTPUT TO_CELSIUS(98.6)
|
||||
@@ -0,0 +1,11 @@
|
||||
// Finance flavor: a loop that updates a FLOAT, with ROUND for reporting.
|
||||
// EXPECT: 1628.89
|
||||
FUNCTION BALANCE_AFTER(Principal : FLOAT, Rate : FLOAT, Years : INTEGER) RETURNS FLOAT
|
||||
DECLARE B : FLOAT
|
||||
B <- Principal
|
||||
FOR Y <- 0 TO Years
|
||||
B <- B * (1 + Rate)
|
||||
NEXT Y
|
||||
RETURN B
|
||||
ENDFUNCTION
|
||||
OUTPUT ROUND(BALANCE_AFTER(1000.0, 0.05, 10) * 100) / 100
|
||||
@@ -0,0 +1,13 @@
|
||||
// Recursion with a DECREASES measure and a REQUIRE.
|
||||
// EXPECT: 6
|
||||
// EXPECT: 1
|
||||
FUNCTION GCD(A : INTEGER, B : INTEGER) RETURNS INTEGER
|
||||
REQUIRE A >= 0 AND B >= 0
|
||||
DECREASES B
|
||||
IF B == 0 THEN
|
||||
RETURN A
|
||||
ENDIF
|
||||
RETURN GCD(B, A MOD B)
|
||||
ENDFUNCTION
|
||||
OUTPUT GCD(48, 18)
|
||||
OUTPUT GCD(17, 5)
|
||||
@@ -0,0 +1,19 @@
|
||||
// An ARRAY of BOOL, nested loops with STEP, and a LIST answer.
|
||||
// EXPECT: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
|
||||
FUNCTION PRIMES_UP_TO(N : INTEGER) RETURNS LIST OF INTEGER
|
||||
DECLARE IsPrime : ARRAY[N + 1] OF BOOL
|
||||
DECLARE Found : LIST OF INTEGER
|
||||
FOR I <- 0 TO N + 1
|
||||
IsPrime[I] <- I >= 2
|
||||
NEXT I
|
||||
FOR I <- 2 TO N + 1
|
||||
IF IsPrime[I] THEN
|
||||
APPEND(Found, I)
|
||||
FOR J <- I * I TO N + 1 STEP I
|
||||
IsPrime[J] <- FALSE
|
||||
NEXT J
|
||||
ENDIF
|
||||
NEXT I
|
||||
RETURN Found
|
||||
ENDFUNCTION
|
||||
OUTPUT PRIMES_UP_TO(30)
|
||||
@@ -0,0 +1,25 @@
|
||||
// Memoised recursion. A FUNCTION cannot take BYREF, so the memo table has to travel through a PROCEDURE
|
||||
// with the answer coming back BYREF too. Finding: this is the idiom; it reads heavier than in most languages.
|
||||
// EXPECT: 6765
|
||||
// EXPECT: 12586269025
|
||||
PROCEDURE FIB(N : INTEGER, BYREF Memo : HASHMAP OF INTEGER : INTEGER, BYREF Result : INTEGER)
|
||||
IF N < 2 THEN
|
||||
Result <- N
|
||||
RETURN
|
||||
ENDIF
|
||||
IF N IN Memo THEN
|
||||
Result <- Memo[N]
|
||||
RETURN
|
||||
ENDIF
|
||||
DECLARE A, B : INTEGER
|
||||
CALL FIB(N - 1, Memo, A)
|
||||
CALL FIB(N - 2, Memo, B)
|
||||
Memo[N] <- A + B
|
||||
Result <- A + B
|
||||
ENDPROCEDURE
|
||||
DECLARE M : HASHMAP OF INTEGER : INTEGER
|
||||
DECLARE R : INTEGER
|
||||
CALL FIB(20, M, R)
|
||||
OUTPUT R
|
||||
CALL FIB(50, M, R)
|
||||
OUTPUT R
|
||||
@@ -0,0 +1,34 @@
|
||||
// Text flavor: splitting a sentence into words by hand, since the notation has no SPLIT, then tallying.
|
||||
// EXPECT: {"a": 2, "is": 2, "rose": 3}
|
||||
// A HASHMAP prints its keys smallest first, whatever order they were added in.
|
||||
FUNCTION WORDS(S : STRING) RETURNS LIST OF STRING
|
||||
DECLARE Out : LIST OF STRING
|
||||
DECLARE W : STRING
|
||||
W <- ""
|
||||
FOR EACH C IN S
|
||||
IF C == ' ' THEN
|
||||
IF LENGTH(W) > 0 THEN
|
||||
APPEND(Out, W)
|
||||
ENDIF
|
||||
W <- ""
|
||||
ELSE
|
||||
W <- W & C
|
||||
ENDIF
|
||||
NEXT C
|
||||
IF LENGTH(W) > 0 THEN
|
||||
APPEND(Out, W)
|
||||
ENDIF
|
||||
RETURN Out
|
||||
ENDFUNCTION
|
||||
FUNCTION TALLY(Ws : LIST OF STRING) RETURNS HASHMAP OF STRING : INTEGER
|
||||
DECLARE T : HASHMAP OF STRING : INTEGER
|
||||
FOR EACH W IN Ws
|
||||
IF W IN T THEN
|
||||
T[W] <- T[W] + 1
|
||||
ELSE
|
||||
T[W] <- 1
|
||||
ENDIF
|
||||
NEXT W
|
||||
RETURN T
|
||||
ENDFUNCTION
|
||||
OUTPUT TALLY(WORDS("a rose is a rose is rose"))
|
||||
@@ -0,0 +1,17 @@
|
||||
// Cryptography flavor: CHAR arithmetic with ORD and CHR, MOD to wrap.
|
||||
// EXPECT: KHOOR, ZRUOG!
|
||||
// EXPECT: HELLO, WORLD!
|
||||
FUNCTION SHIFT(S : STRING, K : INTEGER) RETURNS STRING
|
||||
DECLARE Out : STRING
|
||||
Out <- ""
|
||||
FOR EACH C IN S
|
||||
IF C >= 'A' AND C <= 'Z' THEN
|
||||
Out <- Out & CHR((ORD(C) - ORD('A') + K) MOD 26 + ORD('A'))
|
||||
ELSE
|
||||
Out <- Out & C
|
||||
ENDIF
|
||||
NEXT C
|
||||
RETURN Out
|
||||
ENDFUNCTION
|
||||
OUTPUT SHIFT("HELLO, WORLD!", 3)
|
||||
OUTPUT SHIFT(SHIFT("HELLO, WORLD!", 3), 23)
|
||||
@@ -0,0 +1,17 @@
|
||||
// Two positions moving toward each other; a WHILE with a compound guard.
|
||||
// EXPECT: TRUE
|
||||
// EXPECT: FALSE
|
||||
// EXPECT: TRUE
|
||||
FUNCTION IS_PALINDROME(S : STRING) RETURNS BOOL
|
||||
DECLARE Lo, Hi : INTEGER
|
||||
Lo <- 0
|
||||
Hi <- LENGTH(S) - 1
|
||||
WHILE Lo < Hi AND S[Lo] == S[Hi]
|
||||
Lo <- Lo + 1
|
||||
Hi <- Hi - 1
|
||||
ENDWHILE
|
||||
RETURN Lo >= Hi
|
||||
ENDFUNCTION
|
||||
OUTPUT IS_PALINDROME("racecar")
|
||||
OUTPUT IS_PALINDROME("rose")
|
||||
OUTPUT IS_PALINDROME("")
|
||||
@@ -0,0 +1,19 @@
|
||||
// An in-place sort with a PROCEDURE and BYREF, plus a loop invariant.
|
||||
// EXPECT: [1, 2, 3, 5, 8, 9]
|
||||
PROCEDURE INSERTION_SORT(BYREF L : LIST OF INTEGER)
|
||||
FOR I <- 1 TO LENGTH(L)
|
||||
INVARIANT FORALL K IN [1, I) : L[K - 1] <= L[K]
|
||||
DECLARE Key, J : INTEGER
|
||||
Key <- L[I]
|
||||
J <- I - 1
|
||||
WHILE J >= 0 AND L[J] > Key
|
||||
L[J + 1] <- L[J]
|
||||
J <- J - 1
|
||||
ENDWHILE
|
||||
L[J + 1] <- Key
|
||||
NEXT I
|
||||
ENDPROCEDURE
|
||||
DECLARE Xs : LIST OF INTEGER
|
||||
Xs <- [5, 2, 9, 1, 8, 3]
|
||||
CALL INSERTION_SORT(Xs)
|
||||
OUTPUT Xs
|
||||
@@ -0,0 +1,27 @@
|
||||
// Two-dimensional ARRAYs, triple nested loops, ROWS and COLUMNS.
|
||||
// EXPECT: 19 22
|
||||
// EXPECT: 43 50
|
||||
FUNCTION MATMUL(A : ARRAY[2, 2] OF INTEGER, B : ARRAY[2, 2] OF INTEGER) RETURNS ARRAY[2, 2] OF INTEGER
|
||||
DECLARE C : ARRAY[ROWS(A), COLUMNS(B)] OF INTEGER
|
||||
FOR I <- 0 TO ROWS(A)
|
||||
FOR J <- 0 TO COLUMNS(B)
|
||||
C[I, J] <- 0
|
||||
FOR K <- 0 TO COLUMNS(A)
|
||||
C[I, J] <- C[I, J] + A[I, K] * B[K, J]
|
||||
NEXT K
|
||||
NEXT J
|
||||
NEXT I
|
||||
RETURN C
|
||||
ENDFUNCTION
|
||||
DECLARE A, B, C : ARRAY[2, 2] OF INTEGER
|
||||
A[0, 0] <- 1
|
||||
A[0, 1] <- 2
|
||||
A[1, 0] <- 3
|
||||
A[1, 1] <- 4
|
||||
B[0, 0] <- 5
|
||||
B[0, 1] <- 6
|
||||
B[1, 0] <- 7
|
||||
B[1, 1] <- 8
|
||||
C <- MATMUL(A, B)
|
||||
OUTPUT C[0, 0], " ", C[0, 1]
|
||||
OUTPUT C[1, 0], " ", C[1, 1]
|
||||
@@ -0,0 +1,37 @@
|
||||
// Records in a LIST, a FUNCTION over them, and "find the best".
|
||||
// EXPECT: Bob
|
||||
// EXPECT: 86.5
|
||||
TYPE Student
|
||||
DECLARE Name : STRING
|
||||
DECLARE Marks : LIST OF INTEGER
|
||||
ENDTYPE
|
||||
FUNCTION MEAN(Xs : LIST OF INTEGER) RETURNS FLOAT
|
||||
REQUIRE LENGTH(Xs) >= 1
|
||||
DECLARE Total : INTEGER
|
||||
Total <- 0
|
||||
FOR EACH X IN Xs
|
||||
Total <- Total + X
|
||||
NEXT X
|
||||
RETURN Total / LENGTH(Xs)
|
||||
ENDFUNCTION
|
||||
FUNCTION TOP(Ss : LIST OF Student) RETURNS Student
|
||||
REQUIRE LENGTH(Ss) >= 1
|
||||
DECLARE Best : Student
|
||||
Best <- Ss[0]
|
||||
FOR EACH S IN Ss
|
||||
IF MEAN(S.Marks) > MEAN(Best.Marks) THEN
|
||||
Best <- S
|
||||
ENDIF
|
||||
NEXT S
|
||||
RETURN Best
|
||||
ENDFUNCTION
|
||||
DECLARE A, B : Student
|
||||
DECLARE Class : LIST OF Student
|
||||
A.Name <- "Ann"
|
||||
A.Marks <- [70, 80, 90]
|
||||
B.Name <- "Bob"
|
||||
B.Marks <- [88, 85]
|
||||
APPEND(Class, A)
|
||||
APPEND(Class, B)
|
||||
OUTPUT TOP(Class).Name
|
||||
OUTPUT MEAN(TOP(Class).Marks)
|
||||
@@ -0,0 +1,25 @@
|
||||
// A LIST used as a stack: APPEND to push, REMOVE the last to pop. Balanced brackets.
|
||||
// EXPECT: TRUE
|
||||
// EXPECT: FALSE
|
||||
// EXPECT: FALSE
|
||||
FUNCTION BALANCED(S : STRING) RETURNS BOOL
|
||||
DECLARE Stack : LIST OF CHAR
|
||||
DECLARE Pairs : HASHMAP OF CHAR : CHAR
|
||||
Pairs[')'] <- '('
|
||||
Pairs[']'] <- '['
|
||||
Pairs['}'] <- '{'
|
||||
FOR EACH C IN S
|
||||
IF C == '(' OR C == '[' OR C == '{' THEN
|
||||
APPEND(Stack, C)
|
||||
ELSEIF C IN Pairs THEN
|
||||
IF LENGTH(Stack) == 0 OR Stack[LENGTH(Stack) - 1] != Pairs[C] THEN
|
||||
RETURN FALSE
|
||||
ENDIF
|
||||
REMOVE(Stack, LENGTH(Stack) - 1)
|
||||
ENDIF
|
||||
NEXT C
|
||||
RETURN LENGTH(Stack) == 0
|
||||
ENDFUNCTION
|
||||
OUTPUT BALANCED("{[()()]}")
|
||||
OUTPUT BALANCED("([)]")
|
||||
OUTPUT BALANCED("((")
|
||||
@@ -0,0 +1,30 @@
|
||||
// Graph flavor: breadth-first search with a LIST as a queue (REMOVE at 0) and a SET of seen nodes.
|
||||
// Finding: a neighbour cannot be called Next, because names ignore case and NEXT is a keyword.
|
||||
// EXPECT: [0, 1, 2, 3, 4]
|
||||
FUNCTION BFS(Adj : HASHMAP OF INTEGER : LIST OF INTEGER, Start : INTEGER) RETURNS LIST OF INTEGER
|
||||
DECLARE Queue, Order : LIST OF INTEGER
|
||||
DECLARE Seen : SET OF INTEGER
|
||||
APPEND(Queue, Start)
|
||||
ADD(Seen, Start)
|
||||
WHILE LENGTH(Queue) > 0
|
||||
DECLARE Node : INTEGER
|
||||
Node <- Queue[0]
|
||||
REMOVE(Queue, 0)
|
||||
APPEND(Order, Node)
|
||||
IF Node IN Adj THEN
|
||||
FOR EACH Nb IN Adj[Node]
|
||||
IF NOT (Nb IN Seen) THEN
|
||||
ADD(Seen, Nb)
|
||||
APPEND(Queue, Nb)
|
||||
ENDIF
|
||||
NEXT Nb
|
||||
ENDIF
|
||||
ENDWHILE
|
||||
RETURN Order
|
||||
ENDFUNCTION
|
||||
DECLARE G : HASHMAP OF INTEGER : LIST OF INTEGER
|
||||
G[0] <- [1, 2]
|
||||
G[1] <- [3]
|
||||
G[2] <- [3, 4]
|
||||
G[3] <- [4]
|
||||
OUTPUT BFS(G, 0)
|
||||
@@ -0,0 +1,49 @@
|
||||
// Simulation flavor: one step of Conway's Life on a small two-dimensional ARRAY; a blinker turns.
|
||||
// Finding: the function cannot be called STEP, nor the new grid Next: both are keywords, whatever their case.
|
||||
// EXPECT: 0 1 0
|
||||
// EXPECT: 0 1 0
|
||||
// EXPECT: 0 1 0
|
||||
FUNCTION NEIGHBOURS(G : ARRAY[3, 3] OF INTEGER, R : INTEGER, C : INTEGER) RETURNS INTEGER
|
||||
DECLARE N : INTEGER
|
||||
N <- 0
|
||||
FOR DR <- -1 TO 2
|
||||
FOR DC <- -1 TO 2
|
||||
IF NOT (DR == 0 AND DC == 0) THEN
|
||||
IF R + DR >= 0 AND R + DR < ROWS(G) AND C + DC >= 0 AND C + DC < COLUMNS(G) THEN
|
||||
N <- N + G[R + DR, C + DC]
|
||||
ENDIF
|
||||
ENDIF
|
||||
NEXT DC
|
||||
NEXT DR
|
||||
RETURN N
|
||||
ENDFUNCTION
|
||||
FUNCTION LIFE_STEP(G : ARRAY[3, 3] OF INTEGER) RETURNS ARRAY[3, 3] OF INTEGER
|
||||
DECLARE After : ARRAY[3, 3] OF INTEGER
|
||||
FOR R <- 0 TO 3
|
||||
FOR C <- 0 TO 3
|
||||
DECLARE N : INTEGER
|
||||
N <- NEIGHBOURS(G, R, C)
|
||||
IF G[R, C] == 1 AND (N == 2 OR N == 3) THEN
|
||||
After[R, C] <- 1
|
||||
ELSEIF G[R, C] == 0 AND N == 3 THEN
|
||||
After[R, C] <- 1
|
||||
ELSE
|
||||
After[R, C] <- 0
|
||||
ENDIF
|
||||
NEXT C
|
||||
NEXT R
|
||||
RETURN After
|
||||
ENDFUNCTION
|
||||
DECLARE G : ARRAY[3, 3] OF INTEGER
|
||||
FOR R <- 0 TO 3
|
||||
FOR C <- 0 TO 3
|
||||
G[R, C] <- 0
|
||||
NEXT C
|
||||
NEXT R
|
||||
G[1, 0] <- 1
|
||||
G[1, 1] <- 1
|
||||
G[1, 2] <- 1
|
||||
G <- LIFE_STEP(G)
|
||||
FOR R <- 0 TO 3
|
||||
OUTPUT G[R, 0], " ", G[R, 1], " ", G[R, 2]
|
||||
NEXT R
|
||||
@@ -0,0 +1,29 @@
|
||||
// Statistics flavor: mean and variance in one pass (Welford), returning two values through a record.
|
||||
// EXPECT: 5.0
|
||||
// EXPECT: 4.0
|
||||
TYPE Stats
|
||||
DECLARE Mean : FLOAT
|
||||
DECLARE Variance : FLOAT
|
||||
ENDTYPE
|
||||
FUNCTION RUNNING(Xs : LIST OF FLOAT) RETURNS Stats
|
||||
REQUIRE LENGTH(Xs) >= 2
|
||||
DECLARE N : INTEGER
|
||||
DECLARE Mean, M2, Delta : FLOAT
|
||||
DECLARE Out : Stats
|
||||
N <- 0
|
||||
Mean <- 0.0
|
||||
M2 <- 0.0
|
||||
FOR EACH X IN Xs
|
||||
N <- N + 1
|
||||
Delta <- X - Mean
|
||||
Mean <- Mean + Delta / N
|
||||
M2 <- M2 + Delta * (X - Mean)
|
||||
NEXT X
|
||||
Out.Mean <- Mean
|
||||
Out.Variance <- M2 / N
|
||||
RETURN Out
|
||||
ENDFUNCTION
|
||||
DECLARE S : Stats
|
||||
S <- RUNNING([2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0])
|
||||
OUTPUT S.Mean
|
||||
OUTPUT S.Variance
|
||||
@@ -0,0 +1,17 @@
|
||||
// CASE with half-open ranges on a FLOAT, and OTHERWISE.
|
||||
// EXPECT: A
|
||||
// EXPECT: B
|
||||
// EXPECT: F
|
||||
FUNCTION GRADE(Score : FLOAT) RETURNS STRING
|
||||
DECLARE G : STRING
|
||||
CASE OF Score
|
||||
90 TO 101 : G <- "A"
|
||||
80 TO 90 : G <- "B"
|
||||
70 TO 80 : G <- "C"
|
||||
OTHERWISE : G <- "F"
|
||||
ENDCASE
|
||||
RETURN G
|
||||
ENDFUNCTION
|
||||
OUTPUT GRADE(95.5)
|
||||
OUTPUT GRADE(80.0)
|
||||
OUTPUT GRADE(12.0)
|
||||
@@ -0,0 +1,10 @@
|
||||
// REPEAT ... UNTIL with INPUT, validating until a legal value arrives.
|
||||
// INPUT: 55
|
||||
// INPUT: -3
|
||||
// INPUT: 20
|
||||
// EXPECT: 20
|
||||
DECLARE Threshold : INTEGER
|
||||
REPEAT
|
||||
INPUT Threshold
|
||||
UNTIL Threshold >= 0 AND Threshold <= 40
|
||||
OUTPUT Threshold
|
||||
@@ -0,0 +1,16 @@
|
||||
// Kadane: find the best, with an early return for the empty case.
|
||||
// EXPECT: 6
|
||||
// EXPECT: -1
|
||||
FUNCTION MAX_SUBARRAY(Xs : LIST OF INTEGER) RETURNS INTEGER
|
||||
REQUIRE LENGTH(Xs) >= 1
|
||||
DECLARE Best, Here : INTEGER
|
||||
Best <- Xs[0]
|
||||
Here <- Xs[0]
|
||||
FOR I <- 1 TO LENGTH(Xs)
|
||||
Here <- MAX(Xs[I], Here + Xs[I])
|
||||
Best <- MAX(Best, Here)
|
||||
NEXT I
|
||||
RETURN Best
|
||||
ENDFUNCTION
|
||||
OUTPUT MAX_SUBARRAY([-2, 1, -3, 4, -1, 2, 1, -5, 4])
|
||||
OUTPUT MAX_SUBARRAY([-1])
|
||||
@@ -0,0 +1,18 @@
|
||||
// A HASHMAP from value to position: the lookup pattern every interview asks for.
|
||||
// EXPECT: [0, 2]
|
||||
// EXPECT: []
|
||||
FUNCTION TWO_SUM(Xs : LIST OF INTEGER, Target : INTEGER) RETURNS LIST OF INTEGER
|
||||
DECLARE Seen : HASHMAP OF INTEGER : INTEGER
|
||||
DECLARE Answer : LIST OF INTEGER
|
||||
FOR I <- 0 TO LENGTH(Xs)
|
||||
IF Target - Xs[I] IN Seen THEN
|
||||
APPEND(Answer, Seen[Target - Xs[I]])
|
||||
APPEND(Answer, I)
|
||||
RETURN Answer
|
||||
ENDIF
|
||||
Seen[Xs[I]] <- I
|
||||
NEXT I
|
||||
RETURN Answer
|
||||
ENDFUNCTION
|
||||
OUTPUT TWO_SUM([3, 5, 7, 9], 10)
|
||||
OUTPUT TWO_SUM([1, 2], 10)
|
||||
@@ -0,0 +1,17 @@
|
||||
// SETs: fixed with DEFINE, growing with ADD, membership, LENGTH, SORTED.
|
||||
// EXPECT: TRUE
|
||||
// EXPECT: FALSE
|
||||
// EXPECT: 4
|
||||
// EXPECT: ["ACG", "CGT", "GTA", "TAC"]
|
||||
TYPE BaseSet = SET OF CHAR
|
||||
DEFINE Purines ('A', 'G') : BaseSet
|
||||
OUTPUT 'A' IN Purines
|
||||
OUTPUT 'C' IN Purines
|
||||
DECLARE Seen : SET OF STRING
|
||||
DECLARE T : STRING
|
||||
T <- "ACGTACG"
|
||||
FOR I <- 0 TO LENGTH(T) - 3 + 1
|
||||
ADD(Seen, SLICE(T, I, I + 3))
|
||||
NEXT I
|
||||
OUTPUT LENGTH(Seen)
|
||||
OUTPUT SORTED(Seen)
|
||||
@@ -0,0 +1,25 @@
|
||||
// Number bases: a STRING of digits read left to right, and the reverse with DIV and MOD.
|
||||
// EXPECT: 13
|
||||
// EXPECT: 1101
|
||||
FUNCTION FROM_BINARY(S : STRING) RETURNS INTEGER
|
||||
DECLARE V : INTEGER
|
||||
V <- 0
|
||||
FOR EACH C IN S
|
||||
V <- V * 2 + TO_INTEGER(C)
|
||||
NEXT C
|
||||
RETURN V
|
||||
ENDFUNCTION
|
||||
FUNCTION TO_BINARY(N : INTEGER) RETURNS STRING
|
||||
REQUIRE N >= 1
|
||||
DECLARE S : STRING
|
||||
DECLARE M : INTEGER
|
||||
S <- ""
|
||||
M <- N
|
||||
WHILE M > 0
|
||||
S <- TO_STRING(M MOD 2) & S
|
||||
M <- M DIV 2
|
||||
ENDWHILE
|
||||
RETURN S
|
||||
ENDFUNCTION
|
||||
OUTPUT FROM_BINARY("1101")
|
||||
OUTPUT TO_BINARY(13)
|
||||
@@ -0,0 +1,17 @@
|
||||
// Randomness: RANDINT in a loop and a tally; the lab seeds its random numbers so a run repeats.
|
||||
// EXPECT: 100
|
||||
DECLARE Tally : ARRAY[7] OF INTEGER
|
||||
DECLARE Total : INTEGER
|
||||
FOR F <- 0 TO 7
|
||||
Tally[F] <- 0
|
||||
NEXT F
|
||||
FOR Roll <- 0 TO 100
|
||||
DECLARE Face : INTEGER
|
||||
Face <- RANDINT(1, 7)
|
||||
Tally[Face] <- Tally[Face] + 1
|
||||
NEXT Roll
|
||||
Total <- 0
|
||||
FOR F <- 1 TO 7
|
||||
Total <- Total + Tally[F]
|
||||
NEXT F
|
||||
OUTPUT Total
|
||||
@@ -0,0 +1,17 @@
|
||||
// What the notation offers for text: SLICE, &, UPPER, LOWER, ORD, CHR, TO_STRING, TO_INTEGER.
|
||||
// EXPECT: ATT
|
||||
// EXPECT: GATTACA!
|
||||
// EXPECT: hello
|
||||
// EXPECT: DNA
|
||||
// EXPECT: 65
|
||||
// EXPECT: B
|
||||
// EXPECT: 42 apples
|
||||
// EXPECT: 43
|
||||
OUTPUT SLICE("GATTACA", 1, 4)
|
||||
OUTPUT "GATTACA" & "!"
|
||||
OUTPUT LOWER("HeLLo")
|
||||
OUTPUT UPPER("dna")
|
||||
OUTPUT ORD('A')
|
||||
OUTPUT CHR(66)
|
||||
OUTPUT TO_STRING(42) & " apples"
|
||||
OUTPUT TO_INTEGER("42") + 1
|
||||
@@ -0,0 +1,20 @@
|
||||
// A HASHMAP of LISTs built up, then printed in sorted key order with KEYS.
|
||||
// Finding: the list cannot be called Keys, because built-in names are reserved whatever their case.
|
||||
// EXPECT: a: [1, 3]
|
||||
// EXPECT: b: [2]
|
||||
DECLARE Groups : HASHMAP OF STRING : LIST OF INTEGER
|
||||
DECLARE Ks : LIST OF STRING
|
||||
DECLARE Names : LIST OF STRING
|
||||
DECLARE Values : LIST OF INTEGER
|
||||
Names <- ["a", "b", "a"]
|
||||
Values <- [1, 2, 3]
|
||||
FOR I <- 0 TO LENGTH(Names)
|
||||
IF NOT (Names[I] IN Groups) THEN
|
||||
Groups[Names[I]] <- []
|
||||
ENDIF
|
||||
APPEND(Groups[Names[I]], Values[I])
|
||||
NEXT I
|
||||
Ks <- KEYS(Groups)
|
||||
FOR EACH K IN Ks
|
||||
OUTPUT K & ": " & TO_STRING(Groups[K])
|
||||
NEXT K
|
||||
@@ -0,0 +1,22 @@
|
||||
// BYREF versus by value, side by side.
|
||||
// EXPECT: 2 1
|
||||
// EXPECT: 2 1
|
||||
PROCEDURE SWAP(BYREF X : INTEGER, BYREF Y : INTEGER)
|
||||
DECLARE Temp : INTEGER
|
||||
Temp <- X
|
||||
X <- Y
|
||||
Y <- Temp
|
||||
ENDPROCEDURE
|
||||
PROCEDURE TRY_SWAP(X : INTEGER, Y : INTEGER)
|
||||
DECLARE Temp : INTEGER
|
||||
Temp <- X
|
||||
X <- Y
|
||||
Y <- Temp
|
||||
ENDPROCEDURE
|
||||
DECLARE A, B : INTEGER
|
||||
A <- 1
|
||||
B <- 2
|
||||
CALL SWAP(A, B)
|
||||
OUTPUT A, " ", B
|
||||
CALL TRY_SWAP(A, B)
|
||||
OUTPUT A, " ", B
|
||||
@@ -0,0 +1,11 @@
|
||||
// The reasoning sublanguage used as values: FORALL, EXISTS, SUM, and a set written by rule.
|
||||
// EXPECT: TRUE
|
||||
// EXPECT: FALSE
|
||||
// EXPECT: 15
|
||||
// EXPECT: 3
|
||||
DECLARE L : LIST OF INTEGER
|
||||
L <- [1, 2, 3, 4, 5]
|
||||
OUTPUT FORALL K IN [0, LENGTH(L)) : L[K] > 0
|
||||
OUTPUT EXISTS K IN [0, LENGTH(L)) : L[K] > 10
|
||||
OUTPUT SUM K IN [0, LENGTH(L)) : L[K]
|
||||
OUTPUT LENGTH({ K IN [0, LENGTH(L)) : L[K] MOD 2 == 1 })
|
||||
@@ -0,0 +1,7 @@
|
||||
// What FLOAT does and does not promise.
|
||||
// EXPECT: FALSE
|
||||
// EXPECT: TRUE
|
||||
// EXPECT: 0.30000000000000004
|
||||
OUTPUT 0.1 + 0.2 == 0.3
|
||||
OUTPUT ABS((0.1 + 0.2) - 0.3) < 0.000001
|
||||
OUTPUT 0.1 + 0.2
|
||||
@@ -0,0 +1,38 @@
|
||||
// Linear search three ways: with a flag, with BREAK, with RETURN; all three agree.
|
||||
// EXPECT: 2 2 2
|
||||
// EXPECT: -1 -1 -1
|
||||
FUNCTION FIND_FLAG(Xs : LIST OF INTEGER, X : INTEGER) RETURNS INTEGER
|
||||
DECLARE Found, I : INTEGER
|
||||
Found <- -1
|
||||
I <- 0
|
||||
WHILE I < LENGTH(Xs) AND Found == -1
|
||||
IF Xs[I] == X THEN
|
||||
Found <- I
|
||||
ENDIF
|
||||
I <- I + 1
|
||||
ENDWHILE
|
||||
RETURN Found
|
||||
ENDFUNCTION
|
||||
FUNCTION FIND_BREAK(Xs : LIST OF INTEGER, X : INTEGER) RETURNS INTEGER
|
||||
DECLARE Found : INTEGER
|
||||
Found <- -1
|
||||
FOR I <- 0 TO LENGTH(Xs)
|
||||
IF Xs[I] == X THEN
|
||||
Found <- I
|
||||
BREAK
|
||||
ENDIF
|
||||
NEXT I
|
||||
RETURN Found
|
||||
ENDFUNCTION
|
||||
FUNCTION FIND_RETURN(Xs : LIST OF INTEGER, X : INTEGER) RETURNS INTEGER
|
||||
FOR I <- 0 TO LENGTH(Xs)
|
||||
IF Xs[I] == X THEN
|
||||
RETURN I
|
||||
ENDIF
|
||||
NEXT I
|
||||
RETURN -1
|
||||
ENDFUNCTION
|
||||
DECLARE L : LIST OF INTEGER
|
||||
L <- [4, 8, 15, 16]
|
||||
OUTPUT FIND_FLAG(L, 15), " ", FIND_BREAK(L, 15), " ", FIND_RETURN(L, 15)
|
||||
OUTPUT FIND_FLAG(L, 7), " ", FIND_BREAK(L, 7), " ", FIND_RETURN(L, 7)
|
||||
@@ -0,0 +1,37 @@
|
||||
// A state machine over a STRING: does a token look like a decimal number? CASE on a STRING state.
|
||||
// EXPECT: TRUE
|
||||
// EXPECT: TRUE
|
||||
// EXPECT: FALSE
|
||||
// EXPECT: FALSE
|
||||
FUNCTION IS_NUMBER(S : STRING) RETURNS BOOL
|
||||
DECLARE State : STRING
|
||||
State <- "start"
|
||||
FOR EACH C IN S
|
||||
CASE OF State
|
||||
"start" : IF C >= '0' AND C <= '9' THEN
|
||||
State <- "int"
|
||||
ELSE
|
||||
State <- "bad"
|
||||
ENDIF
|
||||
"int" : IF C == '.' THEN
|
||||
State <- "dot"
|
||||
ELSEIF NOT (C >= '0' AND C <= '9') THEN
|
||||
State <- "bad"
|
||||
ENDIF
|
||||
"dot" : IF C >= '0' AND C <= '9' THEN
|
||||
State <- "frac"
|
||||
ELSE
|
||||
State <- "bad"
|
||||
ENDIF
|
||||
"frac" : IF NOT (C >= '0' AND C <= '9') THEN
|
||||
State <- "bad"
|
||||
ENDIF
|
||||
OTHERWISE : State <- "bad"
|
||||
ENDCASE
|
||||
NEXT C
|
||||
RETURN State == "int" OR State == "frac"
|
||||
ENDFUNCTION
|
||||
OUTPUT IS_NUMBER("42")
|
||||
OUTPUT IS_NUMBER("3.14")
|
||||
OUTPUT IS_NUMBER("3.")
|
||||
OUTPUT IS_NUMBER("x1")
|
||||
@@ -0,0 +1,20 @@
|
||||
// Edge semantics every reader should know: chained comparisons, string order, MIN of a list, SORT of text, nested lists.
|
||||
// EXPECT: TRUE
|
||||
// EXPECT: TRUE
|
||||
// EXPECT: 1
|
||||
// EXPECT: ["apple", "fig", "pear"]
|
||||
// EXPECT: 6
|
||||
// EXPECT: FALSE
|
||||
DECLARE I : INTEGER
|
||||
I <- 3
|
||||
OUTPUT 0 <= I < 5
|
||||
OUTPUT "apple" < "banana"
|
||||
OUTPUT MIN([4, 1, 9])
|
||||
DECLARE Fruit : LIST OF STRING
|
||||
Fruit <- ["pear", "apple", "fig"]
|
||||
SORT(Fruit)
|
||||
OUTPUT Fruit
|
||||
DECLARE Grid : LIST OF LIST OF INTEGER
|
||||
Grid <- [[1, 2, 3], [4, 5, 6]]
|
||||
OUTPUT Grid[1][2]
|
||||
OUTPUT "" IN Fruit
|
||||
@@ -0,0 +1,7 @@
|
||||
// A run that stops: reading one past the end. The lab names the position and the length.
|
||||
// STOPS: index
|
||||
DECLARE T : STRING
|
||||
T <- "GATTACA"
|
||||
FOR I <- 0 TO LENGTH(T) + 1
|
||||
OUTPUT T[I]
|
||||
NEXT I
|
||||
@@ -0,0 +1,11 @@
|
||||
// A run that stops: dividing by zero inside a function; the lab blames the line and shows the values.
|
||||
// STOPS: divide
|
||||
FUNCTION MEAN(Xs : LIST OF INTEGER) RETURNS FLOAT
|
||||
DECLARE Total : INTEGER
|
||||
Total <- 0
|
||||
FOR EACH X IN Xs
|
||||
Total <- Total + X
|
||||
NEXT X
|
||||
RETURN Total / LENGTH(Xs)
|
||||
ENDFUNCTION
|
||||
OUTPUT MEAN([])
|
||||
@@ -0,0 +1,6 @@
|
||||
// A run that stops: recursion with no base case.
|
||||
// STOPS: depth
|
||||
FUNCTION DOWN(N : INTEGER) RETURNS INTEGER
|
||||
RETURN DOWN(N - 1)
|
||||
ENDFUNCTION
|
||||
OUTPUT DOWN(10)
|
||||
@@ -0,0 +1,4 @@
|
||||
// A run that stops: a declared name read before anything is stored in it.
|
||||
// STOPS: unset
|
||||
DECLARE Total : INTEGER
|
||||
OUTPUT Total + 1
|
||||
@@ -0,0 +1,6 @@
|
||||
// A run that stops: a FOR counter read after its loop.
|
||||
// STOPS: unset
|
||||
DECLARE I : INTEGER
|
||||
FOR I <- 0 TO 3
|
||||
NEXT I
|
||||
OUTPUT I
|
||||
@@ -0,0 +1,14 @@
|
||||
// What the checker refuses before anything runs. Each line below is one mistake the guide names.
|
||||
// ERRORS: 5
|
||||
DECLARE T : STRING
|
||||
DECLARE N : INTEGER
|
||||
T <- "GATTACA"
|
||||
N <- 7 / 2
|
||||
T[0] <- 'C'
|
||||
IF T[0] == "G" THEN
|
||||
OUTPUT "g"
|
||||
ENDIF
|
||||
FOR I <- 0 TO 3
|
||||
I <- I + 1
|
||||
NEXT I
|
||||
N = 5
|
||||
@@ -0,0 +1,11 @@
|
||||
// CONTINUE skips a pass; here, unknown bases are not evidence.
|
||||
// EXPECT: 6
|
||||
DECLARE Total : INTEGER
|
||||
Total <- 0
|
||||
FOR EACH B IN "GATNACA"
|
||||
IF B == 'N' THEN
|
||||
CONTINUE
|
||||
ENDIF
|
||||
Total <- Total + 1
|
||||
NEXT B
|
||||
OUTPUT Total
|
||||
@@ -0,0 +1,29 @@
|
||||
// CONSTANT names a number once; STEP walks codon starts; a HASHMAP codon table; a SET of stops.
|
||||
// EXPECT: MAK
|
||||
CONSTANT BasesPerCodon = 3
|
||||
FUNCTION TRANSLATE(T : STRING) RETURNS STRING
|
||||
DECLARE Table : HASHMAP OF STRING : CHAR
|
||||
DECLARE Stops : SET OF STRING
|
||||
DECLARE Out : STRING
|
||||
Table["ATG"] <- 'M'
|
||||
Table["GCC"] <- 'A'
|
||||
Table["AAA"] <- 'K'
|
||||
ADD(Stops, "TAG")
|
||||
ADD(Stops, "TAA")
|
||||
ADD(Stops, "TGA")
|
||||
Out <- ""
|
||||
FOR I <- 0 TO LENGTH(T) - BasesPerCodon + 1 STEP BasesPerCodon
|
||||
DECLARE Codon : STRING
|
||||
Codon <- SLICE(T, I, I + BasesPerCodon)
|
||||
IF Codon IN Stops THEN
|
||||
BREAK
|
||||
ENDIF
|
||||
IF Codon IN Table THEN
|
||||
Out <- Out & Table[Codon]
|
||||
ELSE
|
||||
Out <- Out & '?'
|
||||
ENDIF
|
||||
NEXT I
|
||||
RETURN Out
|
||||
ENDFUNCTION
|
||||
OUTPUT TRANSLATE("ATGGCCAAATAGTTT")
|
||||
@@ -0,0 +1,24 @@
|
||||
// The four text built-ins added after the stress test: SPLIT, JOIN, INDEX_OF, REPLACE.
|
||||
// EXPECT: ["the", "quick", "", "brown", "fox"]
|
||||
// EXPECT: the quick brown fox
|
||||
// EXPECT: 3 -1 2
|
||||
// EXPECT: GAUUACA
|
||||
// EXPECT: read_1:GAT
|
||||
FUNCTION WORDS(S : STRING) RETURNS LIST OF STRING
|
||||
DECLARE Out : LIST OF STRING
|
||||
FOR EACH W IN SPLIT(S, " ")
|
||||
IF LENGTH(W) > 0 THEN
|
||||
APPEND(Out, W)
|
||||
ENDIF
|
||||
NEXT W
|
||||
RETURN Out
|
||||
ENDFUNCTION
|
||||
DECLARE S : STRING
|
||||
S <- "the quick brown fox"
|
||||
OUTPUT SPLIT(S, " ")
|
||||
OUTPUT JOIN(WORDS(S), " ")
|
||||
OUTPUT INDEX_OF("GATTACA", "TAC"), " ", INDEX_OF("GATTACA", 'N'), " ", INDEX_OF([4, 8, 15], 15)
|
||||
OUTPUT REPLACE("GATTACA", "T", "U")
|
||||
DECLARE Fields : LIST OF STRING
|
||||
Fields <- SPLIT("read_1\tGAT\t30", "\t")
|
||||
OUTPUT Fields[0], ":", Fields[1]
|
||||
@@ -0,0 +1,7 @@
|
||||
// A keyword used as a name is one error per name, not a cascade: the rest of the program still parses.
|
||||
// ERRORS: 2
|
||||
DECLARE Step : INTEGER
|
||||
Step <- 1
|
||||
FOR EACH Next IN [1, 2]
|
||||
OUTPUT Next + Step
|
||||
NEXT Next
|
||||
@@ -0,0 +1,17 @@
|
||||
// The numeric built-ins added for mathematics, physics, chemistry and statistics.
|
||||
// EXPECT: 2 3 -3
|
||||
// EXPECT: 1.0 1.0
|
||||
// EXPECT: 10 120
|
||||
// EXPECT: 6 2.5 2.0 2.5
|
||||
// EXPECT: 4.571428571428571 2.138089935299395
|
||||
// EXPECT: 32 5.0
|
||||
// EXPECT: [0.0, 0.0, 0.0] 4
|
||||
// EXPECT: 3.0 3.142
|
||||
OUTPUT FLOOR(2.7), " ", CEIL(2.1), " ", FLOOR(-2.3)
|
||||
OUTPUT ROUND(SIN(PI() / 2) * 1000) / 1000, " ", ROUND(COS(0.0) * 1000) / 1000
|
||||
OUTPUT CHOOSE(5, 2), " ", CHOOSE(10, 3)
|
||||
OUTPUT SUM_OF([1, 2, 3]), " ", MEAN_OF([1, 2, 3, 4]), " ", MEDIAN_OF([3, 1, 2]), " ", MEDIAN_OF([4, 1, 3, 2])
|
||||
OUTPUT VARIANCE_OF([2, 4, 4, 4, 5, 5, 7, 9]), " ", STDEV_OF([2, 4, 4, 4, 5, 5, 7, 9])
|
||||
OUTPUT DOT([1, 2, 3], [4, 5, 6]), " ", NORM_OF([3.0, 4.0])
|
||||
OUTPUT FILL(3, 0.0), " ", LENGTH(FILL(4, 'A'))
|
||||
OUTPUT LOG10(1000.0), " ", ROUND(ATAN2(1.0, 1.0) * 4 * 1000) / 1000
|
||||
@@ -0,0 +1,30 @@
|
||||
// GPU thinking: a PARALLEL FOR whose passes each own one slot (a map), then a sequential reduce.
|
||||
// EXPECT: [1.0, 4.0, 9.0, 16.0]
|
||||
// EXPECT: 30.0
|
||||
// EXPECT: [5, 7, 9]
|
||||
FUNCTION SQUARES(Xs : LIST OF FLOAT) RETURNS LIST OF FLOAT
|
||||
DECLARE Out : LIST OF FLOAT
|
||||
Out <- FILL(LENGTH(Xs), 0.0)
|
||||
PARALLEL FOR I <- 0 TO LENGTH(Xs)
|
||||
DECLARE X : FLOAT
|
||||
X <- Xs[I]
|
||||
Out[I] <- X * X
|
||||
NEXT I
|
||||
RETURN Out
|
||||
ENDFUNCTION
|
||||
|
||||
FUNCTION ADD_VECTORS(A : LIST OF INTEGER, B : LIST OF INTEGER) RETURNS LIST OF INTEGER
|
||||
REQUIRE LENGTH(A) == LENGTH(B)
|
||||
DECLARE C : LIST OF INTEGER
|
||||
C <- FILL(LENGTH(A), 0)
|
||||
PARALLEL FOR I <- 0 TO LENGTH(A)
|
||||
C[I] <- A[I] + B[I]
|
||||
NEXT I
|
||||
RETURN C
|
||||
ENDFUNCTION
|
||||
|
||||
DECLARE Sq : LIST OF FLOAT
|
||||
Sq <- SQUARES([1.0, 2.0, 3.0, 4.0])
|
||||
OUTPUT Sq
|
||||
OUTPUT SUM_OF(Sq)
|
||||
OUTPUT ADD_VECTORS([1, 2, 3], [4, 5, 6])
|
||||
@@ -0,0 +1,10 @@
|
||||
// A shared running total inside a PARALLEL FOR is a data race, and the lab says so.
|
||||
// STOPS: race
|
||||
DECLARE Xs : LIST OF FLOAT
|
||||
DECLARE Acc : FLOAT
|
||||
Xs <- [1.0, 2.0, 3.0]
|
||||
Acc <- 0.0
|
||||
PARALLEL FOR I <- 0 TO LENGTH(Xs)
|
||||
Acc <- Acc + Xs[I]
|
||||
NEXT I
|
||||
OUTPUT Acc
|
||||
@@ -0,0 +1,8 @@
|
||||
// Reading a neighbour that another pass writes is also a race, even with no shared scalar.
|
||||
// STOPS: race
|
||||
DECLARE A : LIST OF INTEGER
|
||||
A <- [5, 6, 7, 8]
|
||||
PARALLEL FOR I <- 0 TO 3
|
||||
A[I] <- A[I + 1]
|
||||
NEXT I
|
||||
OUTPUT A
|
||||
@@ -0,0 +1,25 @@
|
||||
// Physics: where a projectile lands, by stepping Newton's laws, against the closed form.
|
||||
// EXPECT: 10.2 10.2
|
||||
FUNCTION RANGE_BY_STEPS(Speed : FLOAT, Angle : FLOAT, Dt : FLOAT) RETURNS FLOAT
|
||||
DECLARE X, Y, Vx, Vy, G : FLOAT
|
||||
G <- 9.81
|
||||
X <- 0.0
|
||||
Y <- 0.0
|
||||
Vx <- Speed * COS(Angle)
|
||||
Vy <- Speed * SIN(Angle)
|
||||
REPEAT
|
||||
X <- X + Vx * Dt
|
||||
Y <- Y + Vy * Dt
|
||||
Vy <- Vy - G * Dt
|
||||
UNTIL Y <= 0.0
|
||||
RETURN X
|
||||
ENDFUNCTION
|
||||
|
||||
FUNCTION RANGE_EXACT(Speed : FLOAT, Angle : FLOAT) RETURNS FLOAT
|
||||
RETURN Speed * Speed * SIN(2.0 * Angle) / 9.81
|
||||
ENDFUNCTION
|
||||
|
||||
DECLARE Angle : FLOAT
|
||||
Angle <- PI() / 4
|
||||
// Stepping forward overshoots a little, so compare to one decimal place.
|
||||
OUTPUT ROUND(RANGE_BY_STEPS(10.0, Angle, 0.0001) * 10) / 10, " ", ROUND(RANGE_EXACT(10.0, Angle) * 10) / 10
|
||||
@@ -0,0 +1,22 @@
|
||||
// Probability and chemistry: a binomial probability from CHOOSE, and pH from LOG10.
|
||||
// EXPECT: 0.2461
|
||||
// EXPECT: 1.0
|
||||
// EXPECT: 3.0 7.0
|
||||
FUNCTION BINOMIAL(N : INTEGER, K : INTEGER, P : FLOAT) RETURNS FLOAT
|
||||
REQUIRE 0 <= K AND K <= N
|
||||
RETURN CHOOSE(N, K) * P ^ K * (1.0 - P) ^ (N - K)
|
||||
ENDFUNCTION
|
||||
|
||||
FUNCTION PH(Concentration : FLOAT) RETURNS FLOAT
|
||||
REQUIRE Concentration > 0.0
|
||||
RETURN -LOG10(Concentration)
|
||||
ENDFUNCTION
|
||||
|
||||
DECLARE Sum : FLOAT
|
||||
Sum <- 0.0
|
||||
FOR K <- 0 TO 11
|
||||
Sum <- Sum + BINOMIAL(10, K, 0.5)
|
||||
NEXT K
|
||||
OUTPUT ROUND(BINOMIAL(10, 5, 0.5) * 10000) / 10000
|
||||
OUTPUT ROUND(Sum * 1000) / 1000
|
||||
OUTPUT PH(0.001), " ", PH(0.0000001)
|
||||
@@ -0,0 +1,32 @@
|
||||
// Declaring with a starting value on one line, beside the two-line form, at the top, in a routine, and in a loop.
|
||||
// EXPECT: 3
|
||||
// EXPECT: 7 3
|
||||
// EXPECT: a <- b
|
||||
// EXPECT: 6
|
||||
// EXPECT: 2
|
||||
FUNCTION COUNT_BASE(B : CHAR, T : STRING) RETURNS INTEGER
|
||||
DECLARE N : INTEGER <- LENGTH(T)
|
||||
DECLARE Total : INTEGER <- 0 // the running total
|
||||
FOR I <- 0 TO N
|
||||
IF T[I] == B THEN
|
||||
Total <- Total + 1
|
||||
ENDIF
|
||||
NEXT I
|
||||
RETURN Total
|
||||
ENDFUNCTION
|
||||
DECLARE Seq : STRING <- "GATTACA"
|
||||
DECLARE Count : INTEGER
|
||||
Count <- COUNT_BASE('A', Seq)
|
||||
OUTPUT Count
|
||||
DECLARE Len : INTEGER <- LENGTH(Seq)
|
||||
OUTPUT Len, " ", Count
|
||||
DECLARE Arrow : STRING <- "a <- b"
|
||||
OUTPUT Arrow
|
||||
DECLARE Sum : INTEGER <- 0
|
||||
FOR K <- 0 TO 3
|
||||
DECLARE Twice : INTEGER <- 2 * K
|
||||
Sum <- Sum + Twice
|
||||
NEXT K
|
||||
OUTPUT Sum
|
||||
DECLARE Xs : LIST OF INTEGER <- [4, 9]
|
||||
OUTPUT LENGTH(Xs)
|
||||
Reference in new issue
Block a user