prompt.md

Evy is a new language. Bellow is an example of some evy code, and following that are some examples of evy programs

Syntax by Example

The following examples will help you understand the syntax of Evy. For a more formal definition of the syntax, see the Language Specification. Built-in functions, such as print and circle, are documented in theBuilt-ins section.

Comment

// This is a comment

Declaration

x:num     // declaration: num, string, bool, any, []num, {}string
y := 1    // declaration through type inference (num)

Assignment

z = 5

Expression

x := 5 * (y + z)  - 2 / 7.6           // arithmetic number expression
b := !trace and debug or level == ""  // bool expressions

Strings

s1 := "quotation mark : \" "          // escaping
s2 := "abc" + "🥪123"                 // concatenation
s3 := "newline: \n indentation: \t"
s4 := s2[0]                           // "a"
s5 := s2[1:5]                         // "bc🥪1"

if statements

if z > 0 and x != 0
    print "block 1"
else if y != 0 or a == "abc"
    print "block 2"
else
    print "block 3"
end

Nested if

if z > 0 and x != 0
    if startswith str "a"
        print "nested block 1"
    else
        print "nested block 2"
    end
end

Loop statements

while loop

x := 0
while x < 10
    print x
    x = x + 1
end

for … range number

for x := range 5
    print x           // 0 1 2 3 4
end

for x := range 5 10
    print x           // 5 6 7 8 9
end

for x := range 1 10 2 // from to step
    print x           // 1 3 5 7 9
end

for x := range -10
    print x        // nothing. step is 1 by default.
end

for … range array

for x := range [1 2 3]
    print x        // 1 2 3
end

for … range map

m := { name:"Mali" sport:"climbing" }
for key := range m
    print key m[key]
end

break

x := 0
while true
    print "tick... "
    sleep 1
    if x > 9
        print "💥"
        break  // `break` breaks out of the innermost loop
    end
    x = x + 1
end

Function definition

func add:num a:num b:num
    return a + b
end

No return type

func foxprint s:string
    print "🦊 " + s
end

Variadic

func list args:any...
    for arg := range args[:-1]
        printf "%v, " arg
    end
    printf "%v" args[-1]
end

Function calls

n := add 1 2        // 3
foxprint "🐾"       // 🦊 🐾
list 2 true "blue"  // 2, true, blue

Array

a1:[]num
a2:[][]string
a1 = [1 2 3 4]              // type: num[]
a2 = [["1" "2"] ["a" "b"]]  // type: string[][]
a3 := [true false]          // type: bool[]
a4 := ["s1"                 // line break allowed
       "s2"]                // type: string[]
a5 := ["chars" 123]         // type: any[]
a6:[]any                    // type: any[]

Array element access

a1 := [1 2 3 4]
a2 := [["1" "2"] ["a" "b"]]
print a1[1]                  // 2
print a2[1][0]               // "a"
print a1[-1]                  // 4

Concatenation

a := [1 2 3 4]
a = a + [ 100 ]          // [1 2 3 4 100]; optional extra whitespace
a = [0] + a + [101 102]  // [0 1 2 3 4 100 101 102]

Slicing

a := [1 2 3]
b := a[:2]         // [1 2]
b = a[1:2]         // [2]
b = a[-2:]         // [2 3]

Map

m1:{}any // keys used in literals or with `.` must be identifiers.
m1.name = "fox"
m1.age = 42
m1["key with space"] = "🔑🪐"

m2 := {letters:"abc" name:"Jill"} // type: {}string
m3 := {}                          // type: {}any
m4 := {
    letters:"abc"                 // line break allowed
    nums:123
}                                 // type: {}any
m5:{}[]num                        // map of array of numbers
m5.digits = [1 2 3]
m6:{}num
//m6.x = "y"                      // invalid, only num values allowed

Map value access

m := {letters:"abc" name:"Jill"}
s := "letters"
print m.letters    // abc
print m[s]         // abc
print m["letters"] // abc

any

x:any     // any type, default value: false
m1:{}any  // map with any value type
m2 := { letter:"a" number:1 }
arr1:[]any
arr2 := [ "b" 2 ]

Type assertion

x:any
x = [ 1 2 3 4 ]  // concrete type num[]
s := x.([]num)

Type reflection

typeof "abc"          // "string"
typeof true           // "bool"
typeof [ 1 2 ]        // "[]num"
typeof [[1 2] [3 4]]  // "[][]num"

v:any
v = "🐐"
if (typeof v) == "string"
    print "v is a string:" v
    s := v.(string) // type assertion
    print s+s       // 🐐🐐
end

Event handling

on key
    print "key pressed"
end

Evy can only handle a limited set of events, such as key presses, pointer movements, or periodic screen redraws.

Event handlers with parameters

on key k:string
    printf "%q pressed\n" k
end

Example evy programs

// 1. Two Sum
// Solved
// Easy
// Topics
// Companies
// Hint
// Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.
// You may assume that each input would have exactly one solution, and you may not use the same element twice.
// You can return the answer in any order.
// Example 1:
// Input: nums = [2,7,11,15], target = 9
// Output: [0,1]
// Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].
// Example 2:
// Input: nums = [3,2,4], target = 6
// Output: [1,2]
// Example 3:
// Input: nums = [3,3], target = 6
// Output: [0,1]
// Constraints:
// 2 <= nums.length <= 104
// -109 <= nums[i] <= 109
// -109 <= target <= 109
// Only one valid answer exists.
// Follow-up: Can you come up with an algorithm that is less than O(n2) time complexity?

func twosum:[]num nums:[]num target:num
    m:{}num
    for i := range (len nums)
        v := nums[i]
        if has m (sprintf "%v" (target - v))
            return [m[sprintf "%v" (target - v)] i]
        end
        m[sprintf "%v" v] = i
    end
    return []
end

fails := 0
total := 0

func assert want:any got:any
    total = total + 1
    if want != got
        fails = fails + 1
        printf "want != got: want %v got %v\n" want got
    end
end

func finished
    printf "%v of %v tests passed\n" (total - fails) total
end

// -- Test Cases Start -- //
assert [0 1] (twosum [2 7 11 15] 9)
assert [1 2] (twosum [3 2 4] 6)
assert [0 1] (twosum [3 3] 6)
// -- Test Cases End -- //
finished

// 199. Binary Tree Right Side View
// Solved
// Medium
// Topics
// Companies
// Given the root of a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom.
// Example 1:
// Input: root = [1,2,3,null,5,null,4]
// Output: [1,3,4]
// Example 2:
// Input: root = [1,null,3]
// Output: [1,3]
// Example 3:
// Input: root = []
// Output: []
// Constraints:
// The number of nodes in the tree is in the range [0, 100].
// -100 <= Node.val <= 100

func rightSideView:[]any treearr:[]any
    root:any
    root = buildBinaryTree treearr
    queue := []
    res := []
    queue = queue + [root]
    while (len queue) > 0
        size := len queue
        for i := range 0 size
            node:{}any
            node = queue[0].({}any)
            queue = queue[1:]
            if (has node "val") and i == size - 1
                res = res + [node["val"]]
            end
            if (has node "left") and node["left"].({}any) != {}
                queue = queue + [node["left"]]
            end
            if (has node "right") and node["right"].({}any) != {}
                queue = queue + [node["right"]]
            end
        end
    end
    return res
end

fails := 0
total := 0

func assert want:any got:any
    total = total + 1
    if want != got
        fails = fails + 1
        printf "want != got: want %v got %v\n" want got
    end
end

func finished
    printf "%v of %v tests passed\n" (total - fails) total
end

func buildBinaryTree:{}any tree:[]any
    root:{}any
    rootany:any
    rootany = root
    queue := [rootany]
    for i := range 0 (len tree)
        if (len queue) == 0
            break
        end
        node:{}any
        node = queue[0].({}any)
        queue = queue[1:]
        anynull:any
        anynull = "null"
        if tree[i] != anynull
            node["val"] = tree[i]
            node["left"] = {}
            node["right"] = {}
            queue = queue + [node["left"]]
            queue = queue + [node["right"]]
        end
    end
    return root
end

// -- Test Cases Start -- //

assert [1 3 4 ""][:-1] (rightSideView [1 2 3 "null" 5 "null" 4])
assert [1 3 ""][:-1] (rightSideView [1 "null" 3])
assert [] (rightSideView [])
assert [1 3 4 ""][:-1] (rightSideView [1 2 3 4])
// // -- Test Cases End -- //
finished

// 412. Fizz Buzz
// Easy
// Topics
// Companies
// Given an integer n, return a string array answer (1-indexed) where:
// answer[i] == "FizzBuzz" if i is divisible by 3 and 5.
// answer[i] == "Fizz" if i is divisible by 3.
// answer[i] == "Buzz" if i is divisible by 5.
// answer[i] == i (as a string) if none of the above conditions are true.
// Example 1:
// Input: n = 3
// Output: ["1","2","Fizz"]
// Example 2:
// Input: n = 5
// Output: ["1","2","Fizz","4","Buzz"]
// Example 3:
// Input: n = 15
// Output: ["1","2","Fizz","4","Buzz","Fizz","7","8","Fizz","Buzz","11","Fizz","13","14","FizzBuzz"]
// Constraints:
// 1 <= n <= 104

func fizzbuzz:[]string n:num
    ans:[]string
    for i := range 1 (n + 1)
        s:string
        if i % 3 == 0
            s = s + "Fizz"
        end
        if i % 5 == 0
            s = s + "Buzz"
        end
        if s == ""
            s = sprintf "%v" i
        end
        ans = ans + [s]
    end
    return ans
end

fails := 0
total := 0

func assert want:any got:any
    total = total + 1
    if want != got
        fails = fails + 1
        printf "want != got: want %v got %v\n" want got
    end
end

func finished
    printf "%v of %v tests passed\n" (total - fails) total
end

// -- Test Cases Start -- //
assert ["1" "2" "Fizz"] (fizzbuzz 3)
assert ["1" "2" "Fizz" "4" "Buzz"] (fizzbuzz 5)
assert ["1" "2" "Fizz" "4" "Buzz" "Fizz" "7" "8" "Fizz" "Buzz" "11" "Fizz" "13" "14" "FizzBuzz"] (fizzbuzz 15)
// -- Test Cases End -- //
finished

With All of this, solve the following problem:

Write a function has_close_element that checks if in given list of numbers, are any two numbers closer to each other than given threshold.

Write the program in evy: