probs.yml

- name: Hello World
  difficulty: 0
  parts:
  - |
     package main
     import "fmt"
     
     // Returns "Hello World", as is customary in first examples
     func solve() string {
        return ""
     }
  tests:
  - input:
    output:
    - '"Hello World"'
- name: Simple math
  difficulty: 1
  parts:
  - |
     package main
     import "fmt"
     
     // Returns the sum of all of all three parameters
     func solve(a, b, c int) int {
        return 0
     }
  tests:
  - input:
    - 1, 2, 7
    output:
    - 10
  - input:
    - 4, 5, 6
    output:
    - 15
- name: Ifs
  difficulty: 1
  help: &ifhelp http://golangtutorials.blogspot.com/2011/06/control-structures-if-else-statement.html
  hint: |
    Here is an example of how to return the value 7 when a is equal to 3:
       if a == 3 {
          return 7
       }
    Notice the fact that you must say "==" rather than just "=".
  parts:
  - |
     package main
     import "fmt"
     
     // If a is 0, return the sum of b and c
     // If a is 1, return the product of b and c
     // Otherwise, return -1
     func solve(a, b, c int) int {
        return 0
     }
  tests:
  - input:
    - 0, 1, 5
    output:
    - 6
  - input:
    - 0, 5, -9
    output:
    - -4
  - input:
    - 1, 5, 5
    output:
    - 25
  - input:
    - 1, 9, 10
    output:
    - 90
  - input:
    - -1, 5, 6
    output:
    - -1
  - input:
    - 42, 77, 10
    output:
    - -1
- name: Booleans 1
  difficulty: 1
  help: &boolhelp 'http://golang.org/ref/spec#Logical_operators'
  hint: &boolhint | 
    Consider the following input-output relationships for these "boolean operations":
       AND (conjunction):
        
       `true && true` turns into `true`
       `true && false` turns into `false`
       `false && false` turns into `false`
       `false && false` turns into `false`
       
       OR (disjunction):
       `true || true` turns into `true`
       `true || false` turns into `true`
       `false || false` turns into `true`
       `false || false` turns into `false`
       
       NOT (negation, opposite):
       `!true` turns into `false`
       `!false` turns into `true`
       
  parts:
  - |
     package main
     import "fmt"
     
     // Return true if both a and b are true. Otherwise return false.
     func solve(a, b bool) bool {
        return false
     }
  tests:
  - input:
    - true, true
    output:
    - true
  - input:
    - true, false
    output:
    - false
  - input:
    - false, true
    output:
    - false
  - input:
    - false, false
    output:
    - false
- name: Booleans 2
  difficulty: 1
  help: *boolhelp
  hint: *boolhint
  parts:
  - |
     package main
     import "fmt"
     
     // When a is true return the opposite of b. When a is false return true.
     func solve(a, b bool) bool {
        return false
     }
  tests:
  - input:
    - true, true
    output:
    - false
  - input:
    - true, false
    output:
    - true
  - input:
    - false, true
    output:
    - true
  - input:
    - false, false
    output:
    - true
- name: Booleans 3
  difficulty: 2
  help: *boolhelp
  hint: *boolhint
  parts:
  - |
     package main
     import "fmt"
     
     // Return true if exactly one out of a, b, and c is true. Else return false.
     func solve(a, b, c bool) bool {
        return false
     }
  tests:
  - input:
    - false, false, false
    output:
    - false
  - input:
    - false, false, true
    output:
    - true
  - input:
    - false, true, false
    output:
    - true
  - input:
    - false, true, true
    output:
    - false
  - input:
    - true, false, false
    output:
    - true
  - input:
    - true, false, true
    output:
    - false
  - input:
    - true, true, false
    output:
    - false
  - input:
    - true, true, true
    output:
    - false
- name: Average math
  difficulty: 2
  help: 'http://golang.org/ref/spec#Operator_precedence'
  hint: Remember to use parenthesis to ensure order of operation!
  parts:
  - |
     package main
     import "fmt"
     
     // Returns the average of all three parameters
     func solve(a, b, c int) int {
        return 0
     }
  tests:
  - input:
    - 1, 2, 6
    output:
    - 3
  - input:
    - 4, 5, 6
    output:
    - 5
- name: Max
  difficulty: 2
  help: *ifhelp
  hint: If a is greater than b, return a. Else return b.
  parts:
  - |
     package main
     import "fmt"
     
     // Returns the larger of the two parameters 'a' and 'b'. In the
     //   event of a tie return that number.
     func solve(a, b int) int {
        return 0
     }
  tests:
  - input:
    - 1, 2
    output:
    - 2
  - input:
    - 8, 6
    output:
    - 8
  - input:
    - 1, 1
    output:
    - 1
- name: Slices 1
  difficulty: 2
  help: &slicehelp 'http://golang.org/doc/effective_go.html#slices'
  parts:
  - |
     package main
     import "fmt"
     
     // Return the sum of the 0th element and the last element of the slice
     //   You may assume that the slice has at least a single element.
     func solve(a []int) int {
        return 0
     }
  tests:
  - input:
    - '[]int{1, 2}'
    output:
    - 3
  - input:
    - '[]int{1, 4, 5, 6, 7, 8, 9, 0, 1, 4, 8}'
    output:
    - 9
  - input:
    - '[]int{1, 2, 7, 9, -3}'
    output:
    - -2
  - input:
    - '[]int{1}'
    output:
    - 2