Initial commit
Test (in pplus-core) / in-core (push) Failing after 28m44s

This commit is contained in:
alexm committed 2026-11-12 22:23:48 -05:00
commit 568474d52f
1591 files changed
+528213

No files matched your search

+26
View File
@@ -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
+11
View File
@@ -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
+13
View File
@@ -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)
+19
View File
@@ -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)
+25
View File
@@ -0,0 +1,25 @@
// Memoized 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
+34
View File
@@ -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"))
+17
View File
@@ -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)
+17
View File
@@ -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("")
+19
View File
@@ -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
+27
View File
@@ -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]
+37
View File
@@ -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)
+25
View File
@@ -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("((")
+30
View File
@@ -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 neighbor 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)
+49
View File
@@ -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 NEIGHBORS(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 <- NEIGHBORS(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
+29
View File
@@ -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
+17
View File
@@ -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)
+10
View File
@@ -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
+16
View File
@@ -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])
+18
View File
@@ -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)
+17
View File
@@ -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)
+17
View File
@@ -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
+17
View File
@@ -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
+22
View File
@@ -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
+11
View File
@@ -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 })
+7
View File
@@ -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
+38
View File
@@ -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)
+37
View File
@@ -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")
+20
View File
@@ -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
+7
View File
@@ -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
+11
View File
@@ -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([])
+6
View File
@@ -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)
+4
View File
@@ -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
+6
View File
@@ -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
+14
View File
@@ -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
+11
View File
@@ -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")
+24
View File
@@ -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]
+7
View File
@@ -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
+17
View File
@@ -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
+30
View File
@@ -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])
+10
View File
@@ -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 neighbor 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
+25
View File
@@ -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
+22
View File
@@ -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)
+14
View File
@@ -0,0 +1,14 @@
// Sized whole numbers: arithmetic that stays inside its type, wrapping only when asked, and conversions that check.
// EXPECT: 255 0 255
// EXPECT: 1500000000 -2 256
// EXPECT: 8 14 6 255 1024 -4
// EXPECT: 12 12 -128 2147483647
DECLARE Count : UINT8 <- 250
Count <- Count + 5
OUTPUT Count, " ", WRAP(Count + 1, UINT8), " ", MAX_VALUE(UINT8)
DECLARE Big : INT64 <- 3_000_000_000
DECLARE Small : INT32
Small <- INT32(Big DIV 2)
OUTPUT Small, " ", INT16(-2.9), " ", 0xFF + 0b1
OUTPUT BIT_AND(0b1100, 0b1010), " ", BIT_OR(12, 10), " ", BIT_XOR(12, 10), " ", BIT_NOT(UINT8(0)), " ", SHIFT_LEFT(1, 10), " ", SHIFT_RIGHT(-8, 1)
OUTPUT GCD(84, 36), " ", LCM(4, 6), " ", MIN_VALUE(INT8), " ", MAX_VALUE(INT32)
+20
View File
@@ -0,0 +1,20 @@
// Single precision: every FLOAT32 result is rounded to 24 bits, and a literal next to a FLOAT32 is a FLOAT32.
// EXPECT: 1.0000001 0.9999999999999999
// EXPECT: TRUE FALSE
// EXPECT: 0.100000001490116119384765625
// EXPECT: 16777216.0 1.1920929e-7 1.1920929e-7
// EXPECT: 5.551115123125783e-17 0.0
// EXPECT: TRUE TRUE
DECLARE X : FLOAT32 <- 0.1
DECLARE Total32 : FLOAT32 <- 0.0
DECLARE Total64 : FLOAT <- 0.0
FOR I <- 0 TO 10
Total32 <- Total32 + X
Total64 <- Total64 + 0.1
NEXT I
OUTPUT Total32, " ", Total64
OUTPUT X == 0.1, " ", FLOAT64(X) == 0.1
OUTPUT EXACT(X)
OUTPUT FLOAT32(16777217), " ", ULP(FLOAT32(1.0)), " ", EPSILON(FLOAT32)
OUTPUT FMA(0.1, 10.0, -1.0), " ", 0.1 * 10.0 - 1.0
OUTPUT IS_CLOSE(Total32, 1.0, 1e-6, 0.0), " ", IS_CLOSE(Total64, 1.0, 1e-15, 0.0)
+12
View File
@@ -0,0 +1,12 @@
// USE IEEE: NaN and the infinities flow through a calculation as IEEE 754 says, instead of stopping the run.
// EXPECT: infinity -infinity not a number
// EXPECT: TRUE TRUE FALSE TRUE
// EXPECT: not a number -infinity FALSE
USE IEEE
DECLARE Zero : FLOAT <- 0.0
DECLARE Inf : FLOAT
Inf <- 1.0 / Zero
DECLARE NotANumber : FLOAT <- Inf - Inf
OUTPUT Inf, " ", -Inf, " ", NotANumber
OUTPUT IS_INF(Inf), " ", IS_NAN(NotANumber), " ", NotANumber == NotANumber, " ", NotANumber != NotANumber
OUTPUT SQRT(-1.0), " ", LOG(0.0), " ", IS_FINITE(MAX_VALUE(FLOAT64) * 2.0)
+11
View File
@@ -0,0 +1,11 @@
// Elementary functions for numerical work, and the accurate forms near 0.
// EXPECT: 5.0 TRUE -3.0 1024.0
// EXPECT: 1.00000000005e-10 1.000000082740371e-10 9.999999999500001e-11
// EXPECT: -2.0 -1 -2.0 10 0.0
// EXPECT: 3.142 3.142 0.0 0.0 2.718
// EXPECT: TRUE 2.220446049250313e-16
OUTPUT HYPOT(3.0, 4.0), " ", HYPOT(1e200, 1e200) > 1e200, " ", CBRT(-27.0), " ", POW(2.0, 10.0)
OUTPUT EXPM1(1e-10), " ", EXP(1e-10) - 1.0, " ", LOG1P(1e-10)
OUTPUT TRUNC(-2.7), " ", SIGN(-3), " ", COPYSIGN(2.0, -0.0), " ", CLAMP(15, 0, 10), " ", CLAMP(-0.5, 0.0, 1.0)
OUTPUT ROUND(ASIN(1.0) * 2 * 1000) / 1000, " ", ROUND(ACOS(-1.0) * 1000) / 1000, " ", ATAN(0.0), " ", TANH(0.0), " ", ROUND(E() * 1000) / 1000
OUTPUT NEXT_AFTER(1.0, 2.0) - 1.0 == EPSILON(FLOAT64), " ", ULP(1.0)
+12
View File
@@ -0,0 +1,12 @@
// Routines from the library, called like the program's own: a run steps over each one, and the
// prover uses each one's REQUIRE and ENSURE at the call.
// EXPECT: 5.0 4.571428571428571
// EXPECT: 0.0 -0.0615234375
// EXPECT: 0
USE stats
USE md.LennardJones
USE align.NeedlemanWunschScore
DECLARE Samples : LIST OF FLOAT <- [2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0]
OUTPUT Mean(Samples), " ", Variance(Samples)
OUTPUT LennardJones(1.0, 1.0, 1.0), " ", LennardJones(2.0, 1.0, 1.0)
OUTPUT NeedlemanWunschScore("GATTACA", "GCATGCU", 1, -1, -1)
+30
View File
@@ -0,0 +1,30 @@
// Rules the interpreter audit pinned: MOD past 2^53, a LIST OF FLOAT from whole-number literals,
// a function that leaves a WHILE TRUE only by RETURN, an ARRAY filled from a LIST of its length, minus zero.
// EXPECT: -2 2
// EXPECT: [1.0, 2.0] 3.0
// EXPECT: 5
// EXPECT: [1, 2, 9] 3
// EXPECT: 0 -0.0
FUNCTION FIRST_ABOVE(Xs : LIST OF INTEGER, Floor : INTEGER) RETURNS INTEGER
DECLARE I : INTEGER <- 0
WHILE TRUE
IF I >= LENGTH(Xs) THEN
RETURN -1
ENDIF
IF Xs[I] > Floor THEN
RETURN Xs[I]
ENDIF
I <- I + 1
ENDWHILE
ENDFUNCTION
OUTPUT 9007199254740991 MOD -3, " ", (-9007199254740991) MOD 3
DECLARE L : LIST OF FLOAT
L <- [1, 2]
OUTPUT L, " ", SUM_OF(L)
OUTPUT FIRST_ABOVE([1, 5, 9], 3)
DECLARE A : ARRAY[3] OF INTEGER
A <- [3, 1, 2]
SORT(A)
A[2] <- 9
OUTPUT A, " ", LENGTH(A)
OUTPUT 0 * (-1), " ", 0.0 * -1.0
+58
View File
@@ -0,0 +1,58 @@
// Statements whose Mojo the compiler asked for (pixi run mojo-fuzz --statements): a CONTINUE in a REPEAT, a name
// declared in a block and used after it, a value given on one path only, two names that make one Mojo name, a FOR
// EACH over text the body changes, a by-value parameter handed on BYREF, and FILL of a call.
// EXPECT: 2
// EXPECT: 5 2
// EXPECT: 1 0
// EXPECT: 1 2
// EXPECT: abc zzzabc
// EXPECT: 11 [1, 2, 3]
// EXPECT: twice
// EXPECT: [6, 6]
PROCEDURE AddTen(BYREF V : INTEGER)
V <- V + 10
ENDPROCEDURE
PROCEDURE Show(N : INTEGER, L : LIST OF INTEGER)
CALL AddTen(N)
OUTPUT N, " ", L
ENDPROCEDURE
FUNCTION Twice(N : INTEGER) RETURNS INTEGER
OUTPUT "twice"
RETURN N * 2
ENDFUNCTION
DECLARE K : INTEGER <- 0
REPEAT
K <- K + 1
IF K < 3 THEN
CONTINUE
ENDIF
OUTPUT "never ", K
UNTIL K >= 2
OUTPUT K
IF K > 0 THEN
DECLARE Inner : INTEGER <- 5
ENDIF
FOR I <- 0 TO 3
DECLARE Last : INTEGER <- I
NEXT I
OUTPUT Inner, " ", Last
DECLARE W, Z : INTEGER
Z <- 0
IF K > 1 THEN
W <- 1
ENDIF
OUTPUT W, " ", Z
DECLARE RunTotal : INTEGER <- 1
DECLARE RUN_TOTAL : INTEGER <- 2
OUTPUT RunTotal, " ", RUN_TOTAL
DECLARE S : STRING <- "abc"
DECLARE Seen : STRING <- ""
FOR EACH Ch IN S
S <- "z" & S
Seen <- Seen & Ch
NEXT Ch
OUTPUT Seen, " ", S
DECLARE L : LIST OF INTEGER <- [1, 2, 3]
CALL Show(1, L)
DECLARE F : LIST OF INTEGER <- FILL(2, Twice(3))
OUTPUT F