Post History

#10: Post edited by

Arpad Horvath‭ · 2025-08-24T05:48:15Z (about 1 year ago)
Some fixes

Copy Link

Raw

Markdown

# **Haskell**, 66 bytes
-7 bytes thanks to Razetime‭
```
import Data.Complex
(\c->(<2).magnitude$(iterate(\z->z*z+c)c)!!16)
```
~~I use the fact, that if the result is greater than 2, it will be forever then, so I don't need to check this relation in each iterations. It is enough to check it in the end.~~
`iterate(\z->z*z+c)c` gives us a list of the results, the original `c` is the first, then I take 16 elements from the list, so with the `last` function I get the last element which was iterated 15 times, that is $z_{16}$ (the first 0 times, the nth element n-1 times). Then I get the absolute value, and compare it with 2.
Testing:
```
import Data.Complex
f=(\c->(<2).magnitude $ last $ take 16$ iterate (\z -> z*z+c) c)
map f [(-1.862069) :+ (-0.3448276),0.3448276 :+ 0.3448276,0.2068966 :+ 0.7586207]
```
gives
```
[False,True,False]
```
Or if you like it better to print to the standard output:
```
main = do print $ map f [(-1.8620690) :+ (-0.3448276), 0.3448276 :+ 0.3448276, 0.2068966 :+ 0.7586207]
main
```

# **Haskell**, 66 bytes
-7 bytes thanks to Razetime‭
```
import Data.Complex
(\c->(<2).magnitude$(iterate(\z->z*z+c)c)!!16)
```
I use the fact that if the result is greater than 2, it will remain so forever, so I don't need to check this relation in each iteration. It is enough to check it at the end.
`iterate(\z->z*z+c)c` gives us a list of the results, the original `c` is the first, then I take 16 elements from the list, so with the `last` function I get the last element which was iterated 15 times, that is $z_{16}$ (the first 0 times, the nth element n-1 times). Then I get the absolute value, and compare it with 2.
Testing:
```
import Data.Complex
f=(\c->(<2).magnitude $ last $ take 16$ iterate (\z -> z*z+c) c)
map f [(-1.862069) :+ (-0.3448276),0.3448276 :+ 0.3448276,0.2068966 :+ 0.7586207]
```
gives
```
[False,True,False]
```
Or if you like it better to print to the standard output:
```
main = do print $ map f [(-1.8620690) :+ (-0.3448276), 0.3448276 :+ 0.3448276, 0.2068966 :+ 0.7586207]
main
```

#9: Post edited by

Arpad Horvath‭ · 2025-08-23T20:21:28Z (about 1 year ago)
Make the first line a header

Copy Link

Raw

Markdown

# **Haskell**, 66 bytes
-7 bytes thanks to Razetime‭
```
import Data.Complex
(\c->(<2).magnitude$(iterate(\z->z*z+c)c)!!16)
```
~~I use the fact, that if the result is bigger than 2, it will be forever then, so I don't need to check this relation in each iterations. It is enough to check it in the end.~~
`iterate(\z->z*z+c)c` gives us a list of the results, the original `c` is the first, then I take 16 elements from the list, so with the `last` function I get the last element which was iterated 15 times, that is $z_{16}$ (the first 0 times, the nth element n-1 times). Then I get the absolute value, and compare it with 2.
Testing:
```
import Data.Complex
f=(\c->(<2).magnitude $ last $ take 16$ iterate (\z -> z*z+c) c)
map f [(-1.862069) :+ (-0.3448276),0.3448276 :+ 0.3448276,0.2068966 :+ 0.7586207]
```
gives
```
[False,True,False]
```
Or if you like it better to print to the standard output:
```
main = do print $ map f [(-1.8620690) :+ (-0.3448276), 0.3448276 :+ 0.3448276, 0.2068966 :+ 0.7586207]
main
```

# **Haskell**, 66 bytes
-7 bytes thanks to Razetime‭
```
import Data.Complex
(\c->(<2).magnitude$(iterate(\z->z*z+c)c)!!16)
```
I use the fact, that if the result is greater than 2, it will be forever then, so I don't need to check this relation in each iterations. It is enough to check it in the end.
`iterate(\z->z*z+c)c` gives us a list of the results, the original `c` is the first, then I take 16 elements from the list, so with the `last` function I get the last element which was iterated 15 times, that is $z_{16}$ (the first 0 times, the nth element n-1 times). Then I get the absolute value, and compare it with 2.
Testing:
```
import Data.Complex
f=(\c->(<2).magnitude $ last $ take 16$ iterate (\z -> z*z+c) c)
map f [(-1.862069) :+ (-0.3448276),0.3448276 :+ 0.3448276,0.2068966 :+ 0.7586207]
```
gives
```
[False,True,False]
```
Or if you like it better to print to the standard output:
```
main = do print $ map f [(-1.8620690) :+ (-0.3448276), 0.3448276 :+ 0.3448276, 0.2068966 :+ 0.7586207]
main
```

#8: Post edited by

Arpad Horvath‭ · 2025-08-23T20:16:12Z (about 1 year ago)
Make the first line a header

Copy Link

Raw

Markdown

~~Haskell, 66 bytes~~
-7 bytes thanks to Razetime‭
```
import Data.Complex
(\c->(<2).magnitude$(iterate(\z->z*z+c)c)!!16)
```
I use the fact, that if the result is bigger than 2, it will be forever then, so I don't need to check this relation in each iterations. It is enough to check it in the end.
`iterate(\z->z*z+c)c` gives us a list of the results, the original `c` is the first, then I take 16 elements from the list, so with the `last` function I get the last element which was iterated 15 times, that is $z_{16}$ (the first 0 times, the nth element n-1 times). Then I get the absolute value, and compare it with 2.
Testing:
```
import Data.Complex
f=(\c->(<2).magnitude $ last $ take 16$ iterate (\z -> z*z+c) c)
map f [(-1.862069) :+ (-0.3448276),0.3448276 :+ 0.3448276,0.2068966 :+ 0.7586207]
```
gives
```
[False,True,False]
```
Or if you like it better to print to the standard output:
```
main = do print $ map f [(-1.8620690) :+ (-0.3448276), 0.3448276 :+ 0.3448276, 0.2068966 :+ 0.7586207]
main
```

# **Haskell**, 66 bytes
-7 bytes thanks to Razetime‭
```
import Data.Complex
(\c->(<2).magnitude$(iterate(\z->z*z+c)c)!!16)
```
I use the fact, that if the result is bigger than 2, it will be forever then, so I don't need to check this relation in each iterations. It is enough to check it in the end.
`iterate(\z->z*z+c)c` gives us a list of the results, the original `c` is the first, then I take 16 elements from the list, so with the `last` function I get the last element which was iterated 15 times, that is $z_{16}$ (the first 0 times, the nth element n-1 times). Then I get the absolute value, and compare it with 2.
Testing:
```
import Data.Complex
f=(\c->(<2).magnitude $ last $ take 16$ iterate (\z -> z*z+c) c)
map f [(-1.862069) :+ (-0.3448276),0.3448276 :+ 0.3448276,0.2068966 :+ 0.7586207]
```
gives
```
[False,True,False]
```
Or if you like it better to print to the standard output:
```
main = do print $ map f [(-1.8620690) :+ (-0.3448276), 0.3448276 :+ 0.3448276, 0.2068966 :+ 0.7586207]
main
```

#7: Post edited by

Arpad Horvath‭ · 2023-11-13T02:02:39Z (almost 3 years ago)
Shorter

Copy Link

Raw

Markdown

~~Haskell, 73 bytes~~
```
import Data.Complex
~~(\c->(<2).magnitude$last$take 16$iterate(\z->z*z+c)c)~~
```
I use the fact, that if the result is bigger than 2, it will be forever then, so I don't need to check this relation in each iterations. It is enough to check it in the end.
`iterate(\z->z*z+c)c` gives us a list of the results, the original `c` is the first, then I take 16 elements from the list, so with the `last` function I get the last element which was iterated 15 times, that is $z_{16}$ (the first 0 times, the nth element n-1 times). Then I get the absolute value, and compare it with 2.
Testing:
```
import Data.Complex
f=(\c->(<2).magnitude $ last $ take 16$ iterate (\z -> z*z+c) c)
map f [(-1.862069) :+ (-0.3448276),0.3448276 :+ 0.3448276,0.2068966 :+ 0.7586207]
```
gives
```
[False,True,False]
```
Or if you like it better to print to the standard output:
```
main = do print $ map f [(-1.8620690) :+ (-0.3448276), 0.3448276 :+ 0.3448276, 0.2068966 :+ 0.7586207]
main
```

Haskell, 66 bytes
-7 bytes thanks to Razetime‭
```
import Data.Complex
(\c->(<2).magnitude$(iterate(\z->z*z+c)c)!!16)
```
I use the fact, that if the result is bigger than 2, it will be forever then, so I don't need to check this relation in each iterations. It is enough to check it in the end.
`iterate(\z->z*z+c)c` gives us a list of the results, the original `c` is the first, then I take 16 elements from the list, so with the `last` function I get the last element which was iterated 15 times, that is $z_{16}$ (the first 0 times, the nth element n-1 times). Then I get the absolute value, and compare it with 2.
Testing:
```
import Data.Complex
f=(\c->(<2).magnitude $ last $ take 16$ iterate (\z -> z*z+c) c)
map f [(-1.862069) :+ (-0.3448276),0.3448276 :+ 0.3448276,0.2068966 :+ 0.7586207]
```
gives
```
[False,True,False]
```
Or if you like it better to print to the standard output:
```
main = do print $ map f [(-1.8620690) :+ (-0.3448276), 0.3448276 :+ 0.3448276, 0.2068966 :+ 0.7586207]
main
```

#6: Post edited by

Arpad Horvath‭ · 2023-11-11T11:25:47Z (almost 3 years ago)
+import

Copy Link

Raw

Markdown

~~Haskell, 53 bytes~~
```
(\c->(<2).magnitude$last$take 16$iterate(\z->z*z+c)c)
```
I use the fact, that if the result is bigger than 2, it will be forever then, so I don't need to check this relation in each iterations. It is enough to check it in the end.
`iterate(\z->z*z+c)c` gives us a list of the results, the original `c` is the first, then I take 16 elements from the list, so with the `last` function I get the last element which was iterated 15 times, that is $z_{16}$ (the first 0 times, the nth element n-1 times). Then I get the absolute value, and compare it with 2.
Testing:
```
import Data.Complex
f=(\c->(<2).magnitude $ last $ take 16$ iterate (\z -> z*z+c) c)
map f [(-1.862069) :+ (-0.3448276),0.3448276 :+ 0.3448276,0.2068966 :+ 0.7586207]
```
gives
```
[False,True,False]
```
Or if you like it better to print to the standard output:
```
main = do print $ map f [(-1.8620690) :+ (-0.3448276), 0.3448276 :+ 0.3448276, 0.2068966 :+ 0.7586207]
main
```

Haskell, 73 bytes
```
import Data.Complex
(\c->(<2).magnitude$last$take 16$iterate(\z->z*z+c)c)
```
I use the fact, that if the result is bigger than 2, it will be forever then, so I don't need to check this relation in each iterations. It is enough to check it in the end.
`iterate(\z->z*z+c)c` gives us a list of the results, the original `c` is the first, then I take 16 elements from the list, so with the `last` function I get the last element which was iterated 15 times, that is $z_{16}$ (the first 0 times, the nth element n-1 times). Then I get the absolute value, and compare it with 2.
Testing:
```
import Data.Complex
f=(\c->(<2).magnitude $ last $ take 16$ iterate (\z -> z*z+c) c)
map f [(-1.862069) :+ (-0.3448276),0.3448276 :+ 0.3448276,0.2068966 :+ 0.7586207]
```
gives
```
[False,True,False]
```
Or if you like it better to print to the standard output:
```
main = do print $ map f [(-1.8620690) :+ (-0.3448276), 0.3448276 :+ 0.3448276, 0.2068966 :+ 0.7586207]
main
```

#5: Post edited by

Arpad Horvath‭ · 2023-11-11T06:50:20Z (almost 3 years ago)
Back to 16, ay z_1 is the original

Copy Link

Raw

Markdown

Haskell, 53 bytes
```
~~(\c->(<2).magnitude$last$take 17$iterate(\z->z*z+c)c)~~
```
I use the fact, that if the result is bigger than 2, it will be forever then, so I don't need to check this relation in each iterations. It is enough to check it in the end.
`iterate(\z->z*z+c)c` gives us a list of the results, the original `c` is the first, then I take 17 elements from the list, so with the `last` function I get the last element which was iterated 16 times (the first 0 times, the nth element n-1 times). Then I get the absolute value, and compare it with 2.
Testing:
```
import Data.Complex
~~f=(\c->(<2).magnitude $ last $ take 17$ iterate (\z -> z*z+c) c)~~
map f [(-1.862069) :+ (-0.3448276),0.3448276 :+ 0.3448276,0.2068966 :+ 0.7586207]
```
gives
```
[False,True,False]
```
Or if you like it better to print to the standard output:
```
main = do print $ map f [(-1.8620690) :+ (-0.3448276), 0.3448276 :+ 0.3448276, 0.2068966 :+ 0.7586207]
main
```

Haskell, 53 bytes
```
(\c->(<2).magnitude$last$take 16$iterate(\z->z*z+c)c)
```
I use the fact, that if the result is bigger than 2, it will be forever then, so I don't need to check this relation in each iterations. It is enough to check it in the end.
`iterate(\z->z*z+c)c` gives us a list of the results, the original `c` is the first, then I take 16 elements from the list, so with the `last` function I get the last element which was iterated 15 times, that is $z_{16}$ (the first 0 times, the nth element n-1 times). Then I get the absolute value, and compare it with 2.
Testing:
```
import Data.Complex
f=(\c->(<2).magnitude $ last $ take 16$ iterate (\z -> z*z+c) c)
map f [(-1.862069) :+ (-0.3448276),0.3448276 :+ 0.3448276,0.2068966 :+ 0.7586207]
```
gives
```
[False,True,False]
```
Or if you like it better to print to the standard output:
```
main = do print $ map f [(-1.8620690) :+ (-0.3448276), 0.3448276 :+ 0.3448276, 0.2068966 :+ 0.7586207]
main
```

#4: History hidden by

Arpad Horvath‭ · 2023-11-11T06:02:22Z (almost 3 years ago)
Detailed history before this event is hidden because of a redaction.

Copy Link

Raw

Markdown

Haskell, 53 bytes

```
(\c->(<2).magnitude$last$take 17$iterate(\z->z*z+c)c)
```

I use the fact, that if the result is bigger than 2, it will be forever then, so I don't need to check this relation in each iterations. It is enough to check it in the end.

`iterate(\z->z*z+c)c` gives us a list of the results, the original `c` is the first, then I take 17 elements from the list, so with the `last` function I get the last element which was iterated 16 times (the first 0 times, the nth element n-1 times). Then I get the absolute value, and compare it with 2.

Testing:

```
import Data.Complex

f=(\c->(<2).magnitude $ last $ take 17$ iterate (\z -> z*z+c) c)
map f [(-1.862069) :+ (-0.3448276),0.3448276 :+ 0.3448276,0.2068966 :+ 0.7586207]
```

gives

```
[False,True,False]
```


Or if you like it better to print to the standard output:


```
main = do   print $ map f [(-1.8620690) :+ (-0.3448276),  0.3448276 :+ 0.3448276, 0.2068966 :+ 0.7586207]
main
```

#3: Post edited by

Arpad Horvath‭ · 2023-11-11T06:02:22Z (almost 3 years ago)
Some hints how does it work

Copy Link

Raw

Markdown

The detailed changes of this event are hidden because of a redaction.

#2: Post edited by

Arpad Horvath‭ · 2023-11-11T05:44:03Z (almost 3 years ago)
print version

Copy Link

Raw

Markdown

The detailed changes of this event are hidden because of a redaction.

#1: Initial revision by

Arpad Horvath‭ · 2023-11-11T05:24:50Z (almost 3 years ago)

Copy Link

Raw

Markdown

The detailed changes of this event are hidden because of a redaction.

Communities