return early, remove else branches, reorder conditions and top-level functions, remove empty lines, remove unnecessary append(), fix typos, stop using testing package, remove dead code, fix mistakes in subjects, tests and solutions, remove disclaimers, reformat comments, simplify solutions, tests, add more instructions to subjects, remove obsolete files, etc.
Some of the reasons behind those modifications will be added to good-practices.en.md
Some of the exercises are now broken, they will have to be fixed, most of them have a "TODO:" comment.
@ -39,22 +38,21 @@ Some students found this mistake. An update of the subject during the exam treat
2. Always check the formating md
------
---
### fprime <spanstyle="color:#ff3234">(Title of the exercise)</span>
### fprime <spanstyle="color:#ff3234">(Title of the exercise)</span>
#### Instructions <spanstyle="color:#ff3234">(Instructions of the exercise)</span>
Write a program that takes a positive `int` and displays its prime factors, followed by a newline (`'\n'`). <spanstyle="color:#ff3234">(general guidelines, notice the imperative style tense and the avoidance of “you”. “You” is authorized in the case of a presence of a back story where the player is immersed)</span>
- Factors must be displayed in ascending order and separated by `*`. <spanstyle="color:#ff3234">(formating requirement) </span>
- Factors must be displayed in ascending order and separated by `*`. <spanstyle="color:#ff3234">(formating requirement) </span>
- If the number of parameters is different from 1, the program displays a newline. <spanstyle="color:#ff3234">(special case requirement, this case will need to be tested)</span>
- If the number of parameters is different from 1, the program displays a newline. <spanstyle="color:#ff3234">(special case requirement, this case will need to be tested)</span>
- The input, when there is one, will always be valid. <spanstyle="color:#ff3234">(Clarification on what the tester will do, hence giving the student guidelines on the cases to be handled, the tests have to reflect this instruction as well)</span>
- The input, when there is one, will always be valid. <spanstyle="color:#ff3234">(Clarification on what the tester will do, hence giving the student guidelines on the cases to be handled, the tests have to reflect this instruction as well)</span>
- In this exercise the primes factor of 1 is considered as 1. <spanstyle="color:#ff3234">(Handling of exceptional case: THIS Happens to be a mistake, we will see uses this example for the “UPDATING A SUBJECT/TEST PROCEDURE”)</sapn>
- In this exercise the primes factor of 1 is considered as 1. <spanstyle="color:#ff3234">(Handling of exceptional case: THIS Happens to be a mistake, we will see uses this example for the “UPDATING A SUBJECT/TEST PROCEDURE”)</sapn>
| __ student (the same thing as the solutions, just run "cp -aT solutions/ student/")
```
------
---
## **3. Writing a file_test.go (test file for go)**
@ -164,8 +162,8 @@ go
- **If** the source is not in the import section, copy and paste the function, with **lowercase** for the first letter of its name.
- Example: addprimesum_test.go
- Example: addprimesum_test.go
The func isAPrime is fully copied to the file.
@ -176,19 +174,19 @@ Every special case in the subject should be tested. Preferably first. Before the
### <spanstyle="color:#00bae6">**RULE 3**</span>
Whenever possible do at least 1 random test! This is to avoid cheating by predictability of the tests. If the tests are fixed, then the student may create a forest of ifs program to bypass the tester.
Whenever possible do at least 1 random test! This is to avoid cheating by predictability of the tests. If the tests are fixed, then the student may create a forest of ifs program to bypass the tester.
### z01.functions to be used by tester
- Function exercise in a Quest (strlen) 
- Function exercise in a Quest (strlen) 
```go
z01.Challenge(t, studentSol, studentStu) // if the program doesn’t have arguments
z01.Challenge(t, studentSol, studentStu, args...) //if the program has arguments
```
- Program exercise in a Quest (doop) <-Screenshotstobeadded.
- Program exercise in a Quest (doop) <-Screenshotstobeadded.
```go
z01.ChallengeMain(t) // if the program doesn’t have arguments
@ -212,7 +210,7 @@ z01.Challenge(t, studentSol, studentStu) // if the program doesn’t have argume
z01.Challenge(t, studentSol, studentStu, args...) //if the program has arguments
```
------
---
## **4. Testing locally (`go test` or `go test -run=Test\<nameOfTheFunction\>`)**
@ -229,7 +227,7 @@ cp -aT solutions/ student
### Execute a go test in the appropriate folder
- Function exercise in a Quest `(strlen)` 
- Function exercise in a Quest `(strlen)` 
`all/test/go`
@ -237,7 +235,7 @@ cp -aT solutions/ student
go test -run=TestStrlen
```
- Program exercise in a Quest `(doop)`<-Screenshotstobeadded.
- Program exercise in a Quest `(doop)` <-Screenshotstobeadded.
`all/test/go/`
@ -247,7 +245,7 @@ go test -run=TestDoop
- Program exercise in the exam `(dooprog)` Screenshots to be added.
Here you can do just *go test*, because there's only one test file
Here you can do just _go test_, because there's only one test file
`all/test/go/student/dooprog`
@ -263,16 +261,15 @@ go test
go test
```
### **NOTE:** If a go test gives a (cached) result, use this type of command (example with raid3):
### **NOTE:** If a go test gives a (cached) result, use this type of command (example with raid3):
```go test count=1 raid3_test.go```
`go test count=1 raid3_test.go`
The result should be an OK message:
- This means that the test is running correctly when the correct solution is given. If this does not work, the test file is likely to have errors inside.
- This means that the test is running correctly when the correct solution is given. If this does not work, the test file is likely to have errors inside.
- Time should be under 5-6 seconds. If longer, remove some of the iteration of the random tests (for example, less random tests)
- Time should be under 5-6 seconds. If longer, remove some of the iteration of the random tests (for example, less random tests)
- Be watchful of exercises with challenge function: Always test a copy of the variable and not the same variable for both the student and the solution function.
- By setting particular **attributes** to the object
- By associating **children** to the object
- By setting particular **attributes** to the object
- By associating **children** to the object
Children can be added, deleted, reordered in the list. Also, it's possible to configure it in a special way for the parent object, by setting children attributes for all the children.
@ -28,13 +28,13 @@ This documentation explains how to associate a child to a parent object.
#### 3. Set up the new child:
- Enter its name in the input "Add a child name"
- Select your step object in the select input
- Click on "ADD"
- Enter its name in the input "Add a child name"
- Select your step object in the select input
- Click on "ADD"
Your step is then related to its parent. You can see it in the _Children_ section of the parent's object. There, you can now:
- Delete the child from its parent (the actual object of your child will not be deleted).
- Reorder it in the children's list, by dragging it to the place you want.
- Update its original settings by clicking on the eye icon of its reference (redirection to object edit page of the child).
- Editable name field, hit 'enter' or 'cmd + s' or click on the floppy-disk icon to save ;
- Major dependencies visualisation, (where my object is used as a child), click the label to navigate to the dependence ;
- External URL, this is an optional parameter, it's use to point at an other source of content or information needed by the object. We generaly use to point at a Git repository ;
- Link back to the "Objects" page ;
- Editable name field, hit 'enter' or 'cmd + s' or click on the floppy-disk icon to save ;
- Major dependencies visualisation, (where my object is used as a child), click the label to navigate to the dependence ;
- External URL, this is an optional parameter, it's use to point at an other source of content or information needed by the object. We generaly use to point at a Git repository ;
### Pin 2
- Delete Button, Warning there, it will destroy your object! ;
- Type of your Object (`organisation`, `campus`, `onboarding`, `cursus`, `quest`, `exercise`), save on select ;
- Status of your Object (`draft`, `online`, `offline`), save on select ;
- The first and last name of the original author ;
- Delete Button, Warning there, it will destroy your object! ;
- Type of your Object (`organisation`, `campus`, `onboarding`, `cursus`, `quest`, `exercise`), save on select ;
- Status of your Object (`draft`, `online`, `offline`), save on select ;
- The first and last name of the original author ;
### Pin 3
- Object Attribute edition area, manage all the attributes relative to this Object. These attributes will be exposed to its relationship ;
- Object Attribute edition area, manage all the attributes relative to this Object. These attributes will be exposed to its relationship ;
### Pin 4
- Object Children edition area ;
- Children Attributes edition area, these attributes impact and overload all the following children. Works the same way as standard attributes ;
- Add a child, allows to add a child to the children list, more information here -> [Object Child creation](object-child-creation.md) ;
- Children List, allows you to reorganise, delete and edit child. Each child can be overload with its own attributes, the edition works the same way as the original attributes ;
- Object Children edition area ;
- Children Attributes edition area, these attributes impact and overload all the following children. Works the same way as standard attributes ;
- Add a child, allows to add a child to the children list, more information here -> [Object Child creation](object-child-creation.md) ;
- Children List, allows you to reorganise, delete and edit child. Each child can be overload with its own attributes, the edition works the same way as the original attributes ;
More informations about attribute overload system [here](object-attribute-system.md)
- Reduce the number of potential bugs and problems
- The remaining bugs will be easier to identify/isolate & fix
- Easier maintenance
- Lower human capital required
- Reduce the number of potential bugs and problems
- The remaining bugs will be easier to identify/isolate & fix
- Easier maintenance
- Lower human capital required
## Limit security & filtering mechanisms
Especially during the launch, rationale :
- Reduce complexity (see above)
- Alem is a school, not a bank, so the security requirements are lower
- Some students will be able to bypass security systems in all cases
- And they will spread the word quickly
- The only reliable way to identify students will be security cameras and staff attention
- Students will share accounts and USB drives
- They will open connections to the outside and there is no definitive way to prevent this
- We will "hire" the students who have found vulnerabilities using technical skills and creativity
- We cannot anticipate every breach hundreds of students will find & exploit
- Focus on endpoint security rather than network security (firewall on each node)
- Reduce complexity of the network and make it more flexible
- Reduce complexity (see above)
- Alem is a school, not a bank, so the security requirements are lower
- Some students will be able to bypass security systems in all cases
- And they will spread the word quickly
- The only reliable way to identify students will be security cameras and staff attention
- Students will share accounts and USB drives
- They will open connections to the outside and there is no definitive way to prevent this
- We will "hire" the students who have found vulnerabilities using technical skills and creativity
- We cannot anticipate every breach hundreds of students will find & exploit
- Focus on endpoint security rather than network security (firewall on each node)
- Reduce complexity of the network and make it more flexible
## Promote open, neutral network & technologies
Rationale :
- Students will spend more time learning things and exchanging ideas than bypassing censorship
- Students will have more extensive knowledge and skills
- It is better to make them aware of their situation than to try to stop them
- A student's motivation is very much influenced by his or her environment
- An environment with limitations will limit the spectrum of things that stimulate the student's curiosity
- A focus will made on increasing student's empowerement in order to make them feel accountable for their own actions. If the student cheats, he has to understand that he is only hindering his own progress.
- Students will spend more time learning things and exchanging ideas than bypassing censorship
- Students will have more extensive knowledge and skills
- It is better to make them aware of their situation than to try to stop them
- A student's motivation is very much influenced by his or her environment
- An environment with limitations will limit the spectrum of things that stimulate the student's curiosity
- A focus will made on increasing student's empowerement in order to make them feel accountable for their own actions. If the student cheats, he has to understand that he is only hindering his own progress.
@ -9,9 +9,9 @@ Bonus exercises are available in quests 02 / 03 / 04 / 05 / 07 / 08 / 09.
Making a review involves 2 students who are goning to review each other's exercise.
Each user has to :
- **check** the code of the other one on Github
- **bet** if it is going to fail or succeed in the Review interface
- **run** his own exercise in the Review interface to give a result to compare with the bet, and state if it was right or wrong
- **check** the code of the other one on Github
- **bet** if it is going to fail or succeed in the Review interface
- **run** his own exercise in the Review interface to give a result to compare with the bet, and state if it was right or wrong
## Usage
@ -29,13 +29,13 @@ Once you and the other student have confirmed the match, you can go and check th
When you have checked his code, those 4 steps will have to be completed to achieve the review :
- You have to bet if the exercise of the other student will fail or succeed after running the tester
- The other student has to do the same with your exercise and make his own bet, that you will see on the component `Review of your exercise`
<imgwidth="1073"alt="Screenshot 2019-10-17 at 02.20.18"src="img/reviews/Screenshot 2019-10-17 at 02.20.18.jpg">
- You have to bet if the exercise of the other student will fail or succeed after running the tester
- The other student has to do the same with your exercise and make his own bet, that you will see on the component `Review of your exercise`
<imgwidth="1073"alt="Screenshot 2019-10-17 at 02.20.18"src="img/reviews/Screenshot 2019-10-17 at 02.20.18.jpg">
- Once the other student's bet is set, the tester button unblocks and you have to run it on your exercise to output the result determining if your exercise has failed or succeeded ; this result is compared to the other student's bet to determine if it was wrong or right
- The other student also has to run the tester on his exercise to determine his result and so if your bet was wrong or right
<imgwidth="1073"alt="Screenshot 2019-10-17 at 02.22.30"src="img/reviews/Screenshot 2019-10-17 at 02.22.30.jpg">
- Once the other student's bet is set, the tester button unblocks and you have to run it on your exercise to output the result determining if your exercise has failed or succeeded ; this result is compared to the other student's bet to determine if it was wrong or right
- The other student also has to run the tester on his exercise to determine his result and so if your bet was wrong or right
<imgwidth="1073"alt="Screenshot 2019-10-17 at 02.22.30"src="img/reviews/Screenshot 2019-10-17 at 02.22.30.jpg">
In fact, a bet is succeeded if it is equal to the tester output :
<imgwidth="1073"alt="Screenshot 2019-10-17 at 02.24.04"src="img/reviews/Screenshot 2019-10-17 at 02.24.04.jpg">
@ -10,19 +10,19 @@ Screenshots of the installation of Ubuntu in Virtual Box are [here](https://gith
Download and boot the [last Ubuntu release](http://releases.ubuntu.com/19.10/ubuntu-19.10-desktop-amd64.iso).
- Create a new virtual machine named "Ubuntu" with at least 4096 MB of RAM
- Use the fixed size storage allocation (to have more performance)
- In the settings of the VM
- System -> Motherboard : check "Enable EFI"
- System -> Processor : Select at least 2 processors
- Display -> Screen : Put "Video Memory" to the maximum
- Enable 3D acceleration
- Storage
- Remove IDE controller
- Add Optical Drive to the SATA controller
- Choose your Ubuntu ISO image
- Close the settings (click OK)
- Run the VM
- Create a new virtual machine named "Ubuntu" with at least 4096 MB of RAM
- Use the fixed size storage allocation (to have more performance)
- In the settings of the VM
- System -> Motherboard : check "Enable EFI"
- System -> Processor : Select at least 2 processors
- Display -> Screen : Put "Video Memory" to the maximum
- Enable 3D acceleration
- Storage
- Remove IDE controller
- Add Optical Drive to the SATA controller
- Choose your Ubuntu ISO image
- Close the settings (click OK)
- Run the VM
Follow the screenshots (some settings can be personalized, such as keyboard layout, location, password, login automatically, but **do not change the username**)
@ -37,83 +37,95 @@ The program must be executed passing the go source file to be analyze as the fir
- The remaining argument (from 2 to ...):
Can be (without any particular order):
- Allowed imports and functions from a package
- `<package>.*` for full imports (all functions from that package are allowed)
- `<package>`.`<function>` for partial imports (only the function is allowed)
- `<package>`.`<function>#amout` for certain amounts (only certain amount os a function is allowed)
- Ex: `fmt.*` (all functions from `fmt` are allowed), `github.com/01-edu/z01.PrintRune` (only `z01.PrintRune` is allowed), `append#2` (the only amount of `append`'s allowed is 2)
- Allowed built-in functions
- Use the name of the built-in function
- Ex: `make`, `append`, `len`.
- Allowed casting
- by using the type of casting, ex: for allowing `string` casting, use `string`
- Or use the flag `--cast`, to allow every type of casting
- Import relative packages
- Use the relative path
- Ex: `../piscine`, `..`, `.`
- Unallow for loops
- Use the flags `--no-for`.
- Note: remember to use it before the `--no-array` flag.
- ex:
```console
_$ ./rc main.go fmt.* github.com/01-edu/z01.PrintRune len --no-array <...> --no-for
```
the last line produces undesired behaviors.
- Unallow literals
- Use the flag `--no-lit="{PATTERN}"`
- Note: `"{PATTERN}"` must be a valid RegExp.
- ex:
```console
_$ ./rc main.go fmt.* github.com/01-edu/z01.PrintRune len --no-array --no-lit=[b-yB-Y]
```
Can be (without any particular order):
- Allowed imports and functions from a package
- `<package>.*` for full imports (all functions from that package are allowed)
- `<package>`.`<function>` for partial imports (only the function is allowed)
- `<package>`.`<function>#amout` for certain amounts (only certain amount os a function is allowed)
- Ex: `fmt.*` (all functions from `fmt` are allowed), `github.com/01-edu/z01.PrintRune` (only `z01.PrintRune` is allowed), `append#2` (the only amount of `append`'s allowed is 2)
- Allowed built-in functions
- Use the name of the built-in function
- Ex: `make`, `append`, `len`.
- Allowed casting
- by using the type of casting, ex: for allowing `string` casting, use `string`
- Or use the flag `--cast`, to allow every type of casting
- Import relative packages
- Use the relative path
- Ex: `../piscine`, `..`, `.`
- Unallow for loops
- Use the flags `--no-for`.
- Note: remember to use it before the `--no-array` flag.
- ex:
```console
_$ ./rc main.go fmt.* github.com/01-edu/z01.PrintRune len --no-array <...> --no-for
```
the last line produces undesired behaviors.
- Unallow literals
- Use the flag `--no-lit="{PATTERN}"`
- Note: `"{PATTERN}"` must be a valid RegExp.
- ex:
```console
_$ ./rc main.go fmt.* github.com/01-edu/z01.PrintRune len --no-array --no-lit=[b-yB-Y]
```
- Optional lasts arguments
- The flag `--no-array` must be given as the last argument or to signal that all the arguments after are unallowed array types
- The flag `--no-array` must be given as the last argument or to signal that all the arguments after are unallowed array types
### Usage:
- To allow the import of the whole `fmt` package, `z01.PrintRune` and the built-in functions len in the file `main.go`
The imports must be writen exactly the way are writen inside the source code, example:
The imports must be writen exactly the way are writen inside the source code, example:
```console
_$ ./rc main.go fmt.* github.com/01-edu/z01.PrintRune len
```
- More examples:
- import "fmt" is allowed by executing
```console
_$ ./rc sourcefile.go fmt.*
```
- import "go/parser" is allowed by executing
```console
_$ ./rc sourcefile.go go/parser.*
```
- import "github.com/01-edu/z01" is allowed by executing
```console
./rc sourcefile.go github.com/01-edu/z01.*
```
- import "../../../all/tests/go/solutions" is allowed by executing
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testing are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
You have two numbers represented by a linked list, where each NodeAddL contains a single digit.
@ -39,9 +28,7 @@ Here is a possible program to test your function:
```go
package main
import (
"fmt"
)
import "fmt"
func pushFront(node *NodeAddL, num int) *NodeAddL {
###### Does it display the right graphical representation in ASCII as above?
##### Try passing `<a random string>` with at least four lower case letters and three upper case letters.
###### Does it display the right graphical representation in ASCII as expected?
##### Try passing `<a random string>` with at least five lower case letters, a space and two numbers.
###### Does it display the right graphical representation in ASCII as expected?
##### Try passing `<a random string>` with at least one upper case letters and 3 special characters.
###### Does it display the right graphical representation in ASCII as expected?
##### Try passing `<a random string>` with at least two lower case letters, two spaces, one number, two special characters and three upper case letters.
###### Does it display the right graphical representation in ASCII as expected?
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
Write a function that takes a `string` number and its `string` base in parameters and returns its conversion as an `int`.
@ -42,9 +31,7 @@ Here is a possible program to test your function :
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
- Write a function that simulates the behaviour of the `Atoi` function in Go. `Atoi` transforms a number represented as a `string` in a number represented as an `int`.
@ -36,9 +25,7 @@ Here is a possible program to test your function :
- Write a function that simulates the behaviour of the atoi function in Go. Atoi transforms a number defined as a `string` in a number defined as an `int`.
- Write a function that simulates the behaviour of the `Atoi` function in Go. `Atoi` transforms a number defined as a `string` in a number defined as an `int`.
- Atoi returns `0` if the `string` is not considered as a valid number. For this exercise **only valid**`string`chains will be tested. They will only contain one or several digits as characters.
- Atoi returns `0` if the `string` is not considered as a valid number. For this exercise **only valid**`string` will be tested. They will only contain one or several digits as characters.
- For this exercise the handling of the signs `+` or `-` does not have to be taken into account.
- This function will **only** have to return the `int`. For this exercise the `error` return of atoi is not required.
- This function will **only** have to return the `int`. For this exercise the `error` return of `Atoi` is not required.
- Write a function that simulates the behaviour of the atoi function in Go. Atoi transforms a number defined as a `string` in a number defined as an `int`.
- Write a function that simulates the behaviour of the `Atoi` function in Go. `Atoi` transforms a number defined as a `string` in a number defined as an `int`.
- Atoi returns `0` if the `string` is not considered as a valid number. For this exercise **non-valid `string` chains will be tested**. Some will contain non-digits characters.
@ -8,7 +8,7 @@ Symbols considered as brackets are parentheses `(` and `)`, square brackets `[`
An opening bracket must always be closed by the good closing bracket in the correct order. A `string` which does not contain any bracket is considered as a correctly bracketed `string`.
If there is no argument, the program must print only a newline.
If there is no argument, the program must print nothing.
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testing are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
You are given a linked list, where each node contains a single digit.
Change order of linked list so that elements with odd index come first, elements
with even index come afterwards.
Change order of linked list so that elements with odd index come first, elements with even index come afterwards.
You have to return pointer/reference to the beginning of new list
### Expected function and structure
@ -40,9 +28,7 @@ Here is a possible program to test your function:
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
Write a function called `Chunk` that receives as parameters a slice, `slice []int`, and an number `size int`. The goal of this function is to chunk a slice into many sub slices where each sub slice has the length of `size`.
Write a program that takes a `string`, and displays the first `z` character it encounters in it, followed by a newline (`'\n'`). If there are no `z` characters in the string, the program just writes `z` followed by a newline (`'\n'`). If the number of parameters is not 1, the program displays an `z` followed by a newline (`'\n'`).
Write a program that takes a `string`, and displays the first `z` character it encounters in it, followed by a newline (`'\n'`).
If there are no `z` characters in the string, the program just writes `z` followed by a newline (`'\n'`).
If the number of parameters is not 1, the program displays an `z` followed by a newline (`'\n'`).
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
You are given 2 strings. Find out if first string contains second string. If it does, return index of the first string where second string occurs last time. If it does not contain, return "-1"
@ -20,7 +9,7 @@ You are given 2 strings. Find out if first string contains second string. If it
```go
package main
func DoppelGanger(big, little string) int {
func DoppelGanger(s, substr string) int {
}
```
@ -28,9 +17,7 @@ func DoppelGanger(big, little string) int {
Write a program that takes a `string` and displays it with exactly three spaces
between each word, with no spaces or tabs at either the beginning nor the end.
Write a program that takes a `string` and displays it with exactly three spaces between each word, with no spaces or tabs at either the beginning nor the end.
The `string` will be followed by a newline (`'\n'`).
A word is a sequence of alphanumerical characters.
If the number of parameters is not 1, or if there are no word, the program displays
a newline.
If the number of parameters is not 1, or if there are no word, the program displays nothing.
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using 'Content here, content here', making it look like readable English. Many desktop publishing packages and web page editors now use Lorem Ipsum as their default model text, and a search for 'lorem ipsum' will uncover many web sites still in their infancy. Various versions have evolved over the years, sometimes by accident, sometimes on purpose (injected humour and the like).
@ -37,9 +26,7 @@ Here is a possible program to test your function :
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(\`\`\`func main()\`\`\`) even if empty.
- The function main declared needs to **also pass** the \`Restrictions Checker\`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a \`program\`.
### Instructions
Write a function that returns the first prime number that is equal or inferior to the `int` passed as parameter.
@ -32,9 +21,7 @@ Here is a possible [program](TODO-LINK) to test your function :
> For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
Write a function that returns the first `rune` of a `string`.
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker\`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
Write a function called `FoldInt` that simulates the behavior of reduce from JavaScript.
@ -20,7 +9,7 @@ The function should have as parameters a function, `f func(int, int) int` a slic
### Expected function
```go
func FoldInt(f func(int, int) int, arr []int, n int) {
func FoldInt(f func(int, int) int, a []int, n int) {
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
Write a function `ForEach` that, for an `int`array, applies a function on each elements of that array.
Write a function `ForEach` that, for an `int` slice, applies a function on each elements of that slice.
### Expected function
```go
func ForEach(f func(int), arr []int) {
func ForEach(f func(int), a []int) {
}
```
@ -31,8 +20,8 @@ Here is a possible program to test your function :
@ -6,9 +6,7 @@ Write a program that takes a positive `int` and displays its prime factors, foll
- Factors must be displayed in ascending order and separated by `*`.
- If the number of parameters is different from 1, the program displays a newline.
- The input, when there is one, will always be valid.
- If the number of arguments is different from 1, if the argument is invalid or if the integer doesn't have a prime factor, the program displays nothing.
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using 'Content here, content here', making it look like readable English. Many desktop publishing packages and web page editors now use Lorem Ipsum as their default model text, and a search for 'lorem ipsum' will uncover many web sites still in their infancy. Various versions have evolved over the years, sometimes by accident, sometimes on purpose (injected humour and the like).
@ -35,9 +24,7 @@ Here is a possible program to test your function :
##### Try with the argument: `nbr = 919617 and base = 01`
`11100000100001000001`
###### Does the function prints the value?
##### Try with the argument: `nbr = 753639 and base = CHOUMIisDAcat!`
`HIDAHI`
###### Does the function prints the value above?
##### Try with the argument: `nbr = -174336 and base = CHOUMIisDAcat!`
`-MssiD`
###### Does the function prints the value above?
##### Try with the argument: `nbr = -661165 and base = 1`
`NV`
###### Does the function prints the value above?
##### Try with the argument: `nbr = -861737 and base = Zone01Zone01`
`NV`
###### Does the function prints the value above?
##### Try with the argument: `nbr = 125 and base = 0123456789ABCDEF`
`7D`
###### Does the function prints the value above?
##### Try with the argument: `nbr = -125 and base = choumi`
`-uoi`
###### Does the function prints the value above?
##### Try with the argument: `nbr = 125 and base = -ab`
`NV`
###### Does the function prints the value above?
##### Try with the argument: `nbr = -9223372036854775808 and base = 0123456789`
`-9223372036854775808`
###### Does the function prints the value above?
#### doop
##### Try with the arguments: `861 + 870`
`1731`
###### Does the program prints the value above?
##### Try with the arguments: `861 - 870`
`-9`
###### Does the program prints the value above?
##### Try with the arguments: `861 * 870`
`749070`
###### Does the program prints the value above?
##### Try with the arguments: `861 % 870`
`861`
###### Does the program prints the value above?
##### Try with the arguments: `hello + 1`
`0`
###### Does the program prints the value above?
##### Try with the arguments: `1 p 1`
`0`
###### Does the program prints the value above?
##### Try with the arguments: `1 / 0`
`No division by 0`
###### Does the program prints the value above?
##### Try with the arguments: `1 % 0`
`No remainder of division by 0`
###### Does the program prints the value above?
##### Try with the arguments: `1 * 1`
`1`
###### Does the program prints the value above?
##### Try with the arguments: `9223372036854775807 + 1`
`0`
###### Does the program prints the value above?
##### Try with the arguments: `9223372036854775809 - 3`
`0`
###### Does the program prints the value above?
##### Try with the arguments: `9223372036854775807 * 3`
`0`
###### Does the program prints the value above?
#### Atoibase
##### Try with the arguments: `s = bcbbbbaab and base = abc`
`12016`
###### Does the function returns the value above?
##### Try with the arguments: `s = 0001 and base = 01`
`1`
###### Does the function returns the value above?
##### Try with the arguments: `s = 00 and base = 01`
`0`
###### Does the function returns the value above?
##### Try with the arguments: `s = saDt!I!sI and base = CHOUMIisDAcat!`
`11557277891`
###### Does the function returns the value above?
##### Try with the arguments: `s = AAho?Ao and base = WhoAmI?`
`406772`
###### Does the function returns the value above?
##### Try with the arguments: `s = thisinputshouldnotmatter and base = abca`
`0`
###### Does the function returns the value above?
##### Try with the arguments: `s = 125 and base = 0123456789`
`125`
###### Does the function returns the value above?
##### Try with the arguments: `s = uoi and base = choumi`
`125`
###### Does the function returns the value above?
##### Try with the arguments: `s = bbbbbab and base = -ab`
`0`
###### Does the function returns the value above?
#### splitwhitespaces
##### Try with the argument: `str = "The earliest foundations of what would become computer science predate the invention of the modern digital computer"`
`[The earliest foundations of what would become computer science predate the invention of the modern digital computer]`
###### Does the function returns the value above?
##### Try with the argument: `str = Machines for calculating fixed numerical tasks such as the abacus have existed since antiquity,`
`[Machines for calculating fixed numerical tasks such as the abacus have existed since antiquity,]`
###### Does the function returns the value above?
##### Try with the argument: `str = aiding in computations such as multiplication and division .`
##### Try with the argument: `str = aiding in computations such as multiplication and division .`
`[aiding in computations such as multiplication and division .]`
###### Does the function returns the value above?
##### Try with the argument: `str = Algorithms for performing computations have existed since antiquity, even before the development of sophisticated computing equipment.`
##### Try with the argument: `str = Algorithms for performing computations have existed since antiquity, even before the development of sophisticated computing equipment.`
`[Algorithms for performing computations have existed since antiquity, even before the development of sophisticated computing equipment.]`
###### Does the function returns the value above?
##### Try with the argument: `str = Wilhelm Schickard designed and constructed the first working mechanical calculator in 1623.[4]`
`[Wilhelm Schickard designed and constructed the first working mechanical calculator in 1623.[4]]`
###### Does the function returns the value above?
##### Try with the argument: `str = In 1673, Gottfried Leibniz demonstrated a digital mechanical calculator,`
##### Try with the argument: `str = In 1673, Gottfried Leibniz demonstrated a digital mechanical calculator,`
`[In 1673, Gottfried Leibniz demonstrated a digital mechanical calculator,]`
###### Does the function returns the value above?
#### split
##### Try with the arguments:
```
str = |=choumi=|which|=choumi=|itself|=choumi=|used|=choumi=|cards|=choumi=|and|=choumi=|a|=choumi=|central|=choumi=|computing|=choumi=|unit.|=choumi=|When|=choumi=|the|=choumi=|machine|=choumi=|was|=choumi=|finished, and charset = |=choumi=|
```
`[ which itself used cards and a central computing unit. When the machine was finished,]`
###### Does the function returns the value above?
##### Try with the arguments:
```
str = !==!which!==!was!==!making!==!all!==!kinds!==!of!==!punched!==!card!==!equipment!==!and!==!was!==!also!==!in!==!the!==!calculator!==!business[10]!==!to!==!develop!==!his!==!giant!==!programmable!==!calculator, and charset = !==!
```
`[ which was making all kinds of punched card equipment and was also in the calculator business[10] to develop his giant programmable calculator,]`
###### Does the function returns the value above?
##### Try with the arguments:
```
str = AFJCharlesAFJBabbageAFJstartedAFJtheAFJdesignAFJofAFJtheAFJfirstAFJautomaticAFJmechanicalAFJcalculator, and charset = AFJ
```
`[ Charles Babbage started the design of the first automatic mechanical calculator,]`
###### Does the function returns the value above?
##### Try with the arguments:
```
str = <<==123==>>In<<==123==>>1820,<<==123==>>Thomas<<==123==>>de<<==123==>>Colmar<<==123==>>launched<<==123==>>the<<==123==>>mechanical<<==123==>>calculator<<==123==>>industry[note<<==123==>>1]<<==123==>>when<<==123==>>he<<==123==>>released<<==123==>>his<<==123==>>simplified<<==123==>>arithmometer, and charset = <<==123==>>
```
`[ In 1820, Thomas de Colmar launched the mechanical calculator industry[note 1] when he released his simplified arithmometer,]`
###### Does the function returns the value above?
#### convertbase
##### Try with the arguments `nbr = "4506C", baseFrom = "0123456789ABCDEF" and baseTo = "choumi"`
`"hccocimc"`
###### Does the function returns the value above?
##### Try with the arguments `nbr = "babcbaaaaabcb", baseFrom = "abc" and baseTo = "0123456789ABCDEF"`
`"9B611"`
###### Does the function returns the value above?
##### Try with the arguments `nbr = "256850", baseFrom = "0123456789" and baseTo = "01"`
`"111110101101010010"`
###### Does the function returns the value above?
##### Try with the arguments `nbr = "uuhoumo", baseFrom = "choumi" and baseTo = "Zone01"`
`"eeone0n"`
###### Does the function returns the value above?
##### Try with the arguments `nbr = "683241", baseFrom = "0123456789" and baseTo = "0123456789"`
`"683241"`
###### Does the function returns the value above?
#### rotatevowels
##### Try the program without any arguments
###### Does the program displays a new line?
##### Try executing the program passing as argument: `"Hello World"`
`Hollo Werld`
###### Does the program returns the value above?
##### Try executing the program passing as arguments: `"HEllO World" "problem solved"`
`Hello Werld problom sOlvEd`
###### Does the program returns the value above?
##### Try executing the program passing as argument: `"str" "shh" "psst"`
`str shh psst`
###### Does the program returns the value above?
##### Try executing the program passing as argument: `"happy thoughts" "good luck"`
`huppy thooghts guod lack`
###### Does the program returns the value above?
##### Try executing the program passing as argument: `"al's elEphAnt is overly underweight!"`
`il's elephunt es ovirly AndErweaght!`
###### Does the program returns the value above?
#### advancedsortwordarr
##### Try with the arguments
```
array = [The earliest computing device undoubtedly consisted of the five fingers of each hand] and f = strings.Compare
```
slice = [The earliest computing device undoubtedly consisted of the five fingers of each hand] and f = strings.Compare
```
`[The computing consisted device each earliest fingers five hand of of the undoubtedly]`
###### Does the function returns the value above?
##### Try with the arguments
```
array = [The word digital comesfrom "digits" or fingers] and f = strings.Compare
```
slice = [The word digital comesfrom "digits" or fingers] and f = strings.Compare
```
`["digits" The comesfrom digital fingers or word]`
###### Does the function returns the value above?
##### Try with the arguments
```
array = [a A 1 b B 2 c C 3] and f = strings.Compare
```
slice = [a A 1 b B 2 c C 3] and f = strings.Compare
```
`[1 2 3 A B C a b c]`
###### Does the function returns the value above?
##### Try with the arguments
```
array = [The computing consisted device each earliest fingers five hand of of the undoubtedly] and f = func(a, b string) int {
return strings.Compare(b, a)
}
```
slice = [The computing consisted device each earliest fingers five hand of of the undoubtedly] and f = func(a, b string) int {
return strings.Compare(b, a)
}
```
`[undoubtedly the of of hand five fingers earliest each device consisted computing The]`
###### Does the function returns the value above?
##### Try with the arguments
```
array = ["digits" The comesfrom digital fingers or word] and f = func(a, b string) int {
return strings.Compare(b, a)
}
```
slice = ["digits" The comesfrom digital fingers or word] and f = func(a, b string) int {
return strings.Compare(b, a)
}
```
`[word or fingers digital comesfrom The "digits"]`
###### Does the function returns the value above?
##### Try with the arguments
```
array = [1 2 3 A B C a b c] and f = func(a, b string) int {
return strings.Compare(b, a)
}
```
slice = [1 2 3 A B C a b c] and f = func(a, b string) int {
return strings.Compare(b, a)
}
```
`[c b a C B A 3 2 1]`
###### Does the function returns the value above?
#### cat
##### Run the program without arguments and then write: `Hello`
`Hello`
###### Does the program returns the value above?
##### Write: `jaflsdfj`
`jaflsdfj`
###### Does the program returns the value above?
##### Write: `Computer science (sometimes called computation science or computing science`
`Computer science (sometimes called computation science or computing science`
###### Does the program returns the value above?
##### Run the program passing the file: `quest8.txt` as an argument of execution of the program (as shown in the subject)
###### Does the the program displays the same output as in the readme?
##### Run the program with the file: `quest8T.txt`
###### Does the program displays the content of the file?
##### Run the program with the arguments: `quest8T.txt quest8.txt`
###### Does the program displays the content of the file in order?
##### Run the program with a diferent file and then run the system program `cat` with the same file.
###### Are the outputs identical?
##### Run both this program and the system program `cat` passing as an argument a random string that is not the name of a file
###### Are the outputs identical (ignoring the first word of and the capitalization of the output)?
#### ztail
##### Run both ztail and the system command `tail` with the arguments: `-c 20 <filename> `
##### Run both ztail and the system command `tail` with the arguments: `-c 20 <filename>`
###### Are the outputs exactly the same?
##### Run both ztail and the system command `tail` with the arguments: `<filename> -c 23`
###### Are the outputs exactly the same?
##### Run both ztail and the system command `tail` with the arguments: `-c jelrjq 15`
###### Are the outputs exactly the same?
##### Run both ztail and the system command `tail` with the arguments: `-c 11 <filename> jfdklsa`
###### Are the outputs exactly the same?
##### Run both ztail and the system command `tail` with the arguments: `11 -c <filename>`
###### Are the outputs exactly the same?
#### activebits
##### Try with the argument: `n = 15`
`4`
###### Does the function returns the value above?
##### Try with the argument: `n = 17`
`2`
###### Does the function returns the value above?
##### Try with the argument: `n = 4`
`1`
###### Does the function returns the value above?
##### Try with the argument: `n = 11`
`3`
###### Does the function returns the value above?
##### Try with the argument: `n = 9`
`2`
###### Does the function returns the value above?
##### Try with the argument: `n = 12`
`2`
###### Does the function returns the value above?
##### Try with the argument: `n = 2`
`1`
###### Does the function returns the value above?
#### sortlistinsert
##### Try with the arguments: `l = 0-> <nil> and data_ref = 39`
`(0-> 39-> <nil>)`
###### Does the function returns the value above?
##### Try with the arguments: `l = 0-> 1-> 2-> 3-> 4-> 5-> 24-> 25-> 54-> <nil> and data_ref = 33`
Write a [function](TODO-LINK) that simulates the behaviour of the `strings.Split` function in Go. `strings.Split` separates the words of a `string` and puts them in a `string`array.
The separators are the characters of the `charset string` given in parameter.
Write a function that simulates the behaviour of the `strings.Split` function in Go. `strings.Split` separates the words of a `string` and puts them in a `string`slice.
The separators are the characters of the separator string given in parameter.
@ -8,9 +8,7 @@ The program should handle the "`|`" operator, that searches for both strings on
The output of the program should be the results of the regular expression by order of appearance in the string, being themselves identified by a number.
In case the regular expression is not valid, the last argument is empty or there are no matches the program returns a newline ("`\n`").
If the number of arguments is different from 2 the program should print a newline ("`\n`").
If the number of arguments is different from 2, if the regular expression is not valid, if the last argument is empty or there are no matches the program should print nothing.
### Usage
@ -34,8 +32,6 @@ student@ubuntu:~/[[ROOT]]/test$ ./regbrackets "(hi)" "He swore he just saw his s
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using 'Content here, content here', making it look like readable English. Many desktop publishing packages and web page editors now use Lorem Ipsum as their default model text, and a search for 'lorem ipsum' will uncover many web sites still in their infancy. Various versions have evolved over the years, sometimes by accident, sometimes on purpose (injected humour and the like).
@ -36,9 +25,7 @@ Here is a possible program to test your function :
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using 'Content here, content here', making it look like readable English. Many desktop publishing packages and web page editors now use Lorem Ipsum as their default model text, and a search for 'lorem ipsum' will uncover many web sites still in their infancy. Various versions have evolved over the years, sometimes by accident, sometimes on purpose (injected humour and the like).
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
Write a function that takes tree and inverts(flips) and returns it.
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
Write a function that returns `true` if two strings are anagrams, otherwise returns `false`.
Write a function `IsSorted` that returns `true` if the slice of `int` is sorted, and that returns `false` otherwise.
The function passed in parameter returns a positive `int` if `a`(the first argument) is superior to `b`(the second argument),
it returns `0` if they are equal and it returns a negative `int` otherwise.
The function passed in parameter returns a positive `int` if `a` (the first argument) is superior to `b` (the second argument), it returns `0` if they are equal and it returns a negative `int` otherwise.
To do your testing you have to write your own `f` function.
### Expected function
```go
func IsSorted(f func(a, b int) int, tab []int) bool {
func IsSorted(f func(a, b int) int, a []int) bool {
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
- Write a function that simulates the behaviour of the `Itoa` function in Go. `Itoa` transforms a number represented as an `int` in a number represented as a `string`.
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
Write a function that returns the last `rune` of a `string`.
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
Write a function, `lcm`, that returns least common multiple.
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
Write a function `ListRemoveIf` that removes all elements that have a `Data` field equal to the `data_ref` in the argument of the function.
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
Write a function `ListSize` that returns the number of elements in a linked list `l`.
Write a function `Map` that, for an `int`array, applies a function of this type `func(int) bool` on each elements of that array and returns an array of all the return values.
Write a function `Map` that, for an `int`slice, applies a function of this type `func(int) bool` on each elements of that slice and returns a slice of all the return values.
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
Write a function, `Max`, that returns the maximum value in a slice of integers.
@ -18,7 +7,7 @@ Write a function, `Max`, that returns the maximum value in a slice of integers.
### Expected function
```go
func Max(arr []int) int {
func Max(a []int) int {
}
```
@ -30,9 +19,7 @@ Here is a possible program to test your function :
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testing are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
Given two binary trees and imagine that when you put one of them to cover the other, some nodes of the two trees are overlapped while the others are not.
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
There was a vote. There are people who voted positively, negatively, and randomly.
Write a **program** that prints the corresponding letter in the `n` position of the classic latin alphabet, where `n` is each argument received.
Write a **program** that prints the corresponding letter in the `n` position of the latin alphabet, where `n` is each argument received.
For example `1` matches `a`, `2` matches `b`, etc. If `n` does not match a valid position of the alphabet or if the argument is not an integer, the **program** should print a space (" ").
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
Write a function that returns the nth `rune` of a `string`.
For this exercise a function will be tested **with the exam own main**. However the student **still needs** to submit a structured program:
This means that:
- The package needs to be named `package main`.
- The submitted code needs one declared function main(`func main()`) even if empty.
- The function main declared needs to **also pass** the `Restrictions Checker`(illegal functions tester). It is advised for the student to just empty the function main after its own testings are done.
- Every other rules are obviously the same than for a `program`.
### Instructions
Write a function that takes `(arr [10]int)`, and displays the memory as in the example.
Xavier Petit
4 years ago
committed by