The solution is to add one extra `serialize_word` call in the end:

```
%builtins output

from starkware.cairo.common.serialize import serialize_word

func main{output_ptr: felt*}() {
    // Output 100.
    serialize_word(100);
    // Output 200.
    serialize_word(200);
    // Output 300.
    serialize_word(300);
    // Output 300.
    serialize_word(300);

    // Solution: Output 400.
    serialize_word(400);

    return ();
}
```


Can you help how to change the code so that it outputs 400 as well?

```
// The following code outputs the numbers 100, 200, 300.
// 1. Click on "Run" to see the output.
// 2. Change it to output 400 as well.

// Use the output builtin.
%builtins output

// Import the serialize_word() function.
from starkware.cairo.common.serialize import serialize_word

func main{output_ptr: felt*}() {
// Output 100 by calling serialize_word.
serialize_word(100);
// Output 200.
serialize_word(200);
// Output 300.
serialize_word(300);
// Return.
return ();
}
```

---

> Answers to this question are a part of the ✨ **17 days of Cairo Lang with Playground & Newton.** ✨ 

*Vote for your favorite answer - the best answer will win a $10 award. A new day – a new reward! During the next 17 days, our goal is to attract more developers to the Cairo language and to systematize the knowledge of Cairo lang. [Read rules](https://www.notion.so/17-days-of-Cairo-Lang-with-Playground-Newton-550dfcda6a2d449ca468be293c776578)*

How to make output like "hello world" in Cairo Language (StarkNet)?

It is required to add `add1` function before `add1_square`:

```
func add1(y: felt) -> (y: felt) {
    return (y=y + 1);
}
```

By looking at the usage of `add1` in `add1_square`, we see that the required argument should be called `y` and should be of type `felt`. Also, since the `add1` is simple, the increment is done within the return statement without sacrificing readability.

# Output

```
Number of steps: 10
Program hash: 0x00866f10be8849f5d7e293e35c35ae1b178820a025edf7da20a8b64e3e7601a8
```

Hello! This is Day 2 of the 17 days of the Cairo challenge. And I have no idea how to solve the [playground](https://www.cairo-lang.org/playground/) exercise “Functions”. Perhaps you can help me?

```python
// The following code is missing the function `add1`.
// 1. Click on "Run" to see the error.
// 2. Write the function `add1`, based on `add1_square`, so
//    that the program terminates successfully.
//
// Note that `add1` doesn't have to call other functions.
//
// You can learn more about functions [here](https://www.cairo-lang.org/docs/how_cairo_works/functions.html).

// Write your code here.

func add1_square(x: felt) -> (x: felt) {
    // Call `add1` and unpack the result into `z`.
    let (z) = add1(y=x);
    return (x=z * z);
}

func main() {
    // Call `add1_square` and save the result into `res`.
    let (res) = add1_square(x=12);

    // Verify the computation.
    assert res = (12 + 1) * (12 + 1);
    return ();
}
```

---
> Answers to this question are a part of the ✨ **17 days of Cairo Lang with Playground & Newton.** ✨ 

*Vote for your favorite answer - the best answer will win a $10 award. A new day – a new reward! During the next 17 days, our goal is to attract more developers to the Cairo language and to systematize the knowledge of Cairo lang. [Read rules](https://www.notion.so/17-days-of-Cairo-Lang-with-Newton-550dfcda6a2d449ca468be293c776578)*

How to write a function in Cairo Lang (StarkNet)?

I would always recommend starting with the [official documentation](https://www.cairo-lang.org/docs/) (especially [hands on path](https://www.cairo-lang.org/docs/hello_cairo/index.html#hello-cairo)) and the [playground](https://www.cairo-lang.org/playground/). Learning more about how Cairo works is also beneficial for a deeper understanding of the StarkNet ecosystem, but I think it is not necessary for the beginning.

Once you learn about data representation, you may also want to compare two `felt`s or `Uint256`s, since there are no number comparison operators like in standard languages. You can check `cmp` utils functions built into the language: [`math_cmp`](https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/cairo/common/math_cmp.cairo) and [`uint256_cmp`](https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/cairo/common/uint256.cairo).

If you're coming from a Solidity background, you probably heard about OpenZeppelin. They have a [repo with StarkNet contracts](https://github.com/OpenZeppelin/cairo-contracts) implemented in Cairo. I find it useful, not just as a good library, but as an inspiration for code abstraction and organization, and Cairo best practices.

Other useful resources:
* [Cairo Mummies](https://triality.org/education/course/cairomummies) courses
* [Cairo resources Twitter thread](https://mobile.twitter.com/Starknet_edu/status/1529371701334581249)
* [What is Cairo? Resources and Tools – Nostra Devs 01](https://mirror.xyz/0x845605C411132BAA06024a521a85B653F3C802dF/oOISOf8vdxf-uiXrAGJVYxXdXuW81IauMIC7RzrznLQ) (also there's `felt` and `Uint256` post on the blog).
* [Practical StarkNet lessons learned](https://hackmd.io/@RoboTeddy/BJZFu56wF)
* Not strictly Cairo resources, but useful for better understanding StarkNet: [STARK math Twitter thread](https://twitter.com/EliBenSasson/status/1578380154476208131)

There are many people who are pretty new to Cairo Language, so this thread is about some good resources, to begin with. What projects, educational courses, Github Repos etc. about StarkNet can you recommend?

---
This question is participating in [Newton Bounties | Incentivized Test Program](https://newtonso.notion.site/Newton-Bounties-Incentivized-Test-Program-94322ad48e7d40a3adcf36f6b26174cd)
Every verified valid question gets $10 USDC (mainnet)

Popular tags

Profile

<name_unset>

Wallet address: 0xB8838A2213dd9152e4cd2F1BB185a01eB5B7956a

Recent questions

Recent answers