Move the engine core into core/, a project of its own (pplus-core)
What programs mean (the languages, translators, Mojo checker and
interpreter, prover, fuzzer, machine model, catalog problems and the Mojo
corpus with godbolt's stored answers) was mixed into the site's tree, so a
change to the prover and a change to a button went through the same gate
and the same docs. This moves all of it under core/, laid out as its own
repository, ready to be extracted with its history and pinned here as a
git submodule.
- core/: src/{engines,services,sync,mojo,exercises,curriculum,common},
mojo/, syntax/mojo.xml, its tests (with Workspace and workForProblem in
place of the site's Session), scripts (corpus pipeline, play, the
exercise and probe starters, engines export/diff), and its docs
(engines, trust, mojo-corpus, exercises, coverage). Its own pixi.toml,
package.json, README, AGENTS.md and CI workflow.
- core/tests/boundary.test.mjs: library modules use no DOM, import no
page widget, and import nothing outside src/.
- core/scripts/cli.mjs: pixi run cli check|run|prove|fuzz|translate.
- core/scripts/dafny.py: Dafny 4.11.0 pinned by version and SHA-256 per
platform, fetched into .tools/ (pixi run dafny-fetch, pixi run dafny).
- The site imports core only as #core/<path>.js: an import map in
index.html, "imports" in package.json for node, core's declarations for
tsc. The site's TypeScript builds core first (npm run build).
- assemble.sh, the Quarto engine copy, the render cache key, check-pages,
quarto-export and quarto-css read core/dist and core/mojo; quarto-css
copies core's syntax/mojo.xml into the extension.
- Site tests that covered engines moved to core; the rest keep Session.
- README, AGENTS.md, docs/app.md, docs/deploy.md and the CI workflow
describe the split (checkout with submodules; core's tests and corpus
status run against the pinned commit).
Gate: site 110 pass; core 307 pass; corpus status --strict passes.
Manual check: the assembled site opens Bridge (count-base-proved),
Developer and Hardware (count-base) with the editor, the stepper and the
board, and no module errors.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FgvbRdoEheAHqsRmr2WuKZ
This commit is contained in:
1567 files changed
+3670
-981
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