The program that will find the next prime number

Question 1

Intro:

You accidentally corrupted the flow of time with a device you made for fun, that turned out to be a time machine. As a result, you got pushed to the far future. You realized that computing, processing power, and computers in general have been evolved by a huge amount, an infinite amount to be precise. So you grab yourself a computer with infinite memory and processing power. You have no idea how it can have infinite memory and infinite processing power, but you just accept it and return to the present.

Challenge:

You heard that the person who discovered the currently largest prime 2^74,207,281 − 1 got paid 100ドル.000. You decide to make a program that finds the next prime, since you want to get back the money you spent for the computer. You make one that takes input of a number, and finds the next prime number, either by bruteforcing or any other method.

Clarifications: You have a hypothetical machine with infinite memory and processing power. Your program MUST NOT be limited (e.g.: C#'s int's can store from -2,147,483,648 to 2,147,483,647), well your program must be able to store, and work with any number of any size. You have infinite resources, so you shouldnt care if you would run out of memory if you allowed that.

Example I/O:
Input: The currently largest discovered prime with 22,338,618 digits.
Output: Exactly the next prime

Obviously, you dont have to prove that it works, as it would take a ton of time to compute in a physical machine. But if you moved your program to a hypothetical machine with infinite processing power / memory, it should compute instantly.

Finding the next prime and checking if a number is a prime, are two completely different things

Question 2

Does it have to specifically be the next prime? Lots of prime searching algorithms for large primes only search certain types of numbers and therefore sometimes miss out primes...

Question 3

I think you should add some serious test cases.

Question 4

"Your program MUST NOT be limited" but on the basis of the example I suspect that every single language in existence counts as limited if fit no other reason than using a finite type to address memory.

Question 5

How is this different from the primality test question? Any reasonable method is just going to be a fairly simple wrapper of the original or a builtin.

Question 6

@mbomb007 why? All of the answers except the builtin ones seen to just add an extra wrapper.

Question 7

Mathematica, 9 bytes

NextPrime

Question 8

... Does this actually work?

Question 9

Of course, Mathematica always has a builtin

Question 10

@wizzwizz4, sure, Try it online!

Question 11

Python 3, 45 bytes

f=lambda n,k=1,m=1:m%k*k>n or-~f(n,k+1,m*k*k)

Try it online!

Question 12

I believe this is Wilson's Theorem in disguise. k is equal to the final result, m contains (k-1)!^2. Since (k-1)! = -1 mod k only holds when k is prime, we have (k-1)!(k-1)! = 1 mod k, which when multiplied by k will be k itself. You calculate the square to get rid of the only exception of (k-1)! = 0 mod k for composite k, which occurs for k = 4. Correct?

Question 13

Yes, that is correct.

Question 14

This throws RecursionError: maximum recursion depth exceeded in comparison for f(1000)

Question 15

@ovs The question says we have infinite memory. Therefore we can assume an infinitely high recursion depth limit, and thus not worry about RecursionError.

Question 16

Regex `🐇` (PCRE2 _{^{v10.35 or later}}), (削除) 80 (削除ここまで) (削除) 77 (削除ここまで) 69 bytes

^(?=(?*x(x*))(?!(?*(xx+)(x+$))(?=2円*(x+)).*(?=3円4円$)1円2円*$))1円x+|\B|$

Attempt This Online!

Takes its input in unary, as a string of x characters whose length represents the number. Returns its output as the number of ways the regex can match. (The rabbit emoji indicates this output method.)

This is the first 🐇-regex I've written that can be really said to compute its result before turning it into a number of possible matches. This output method allows actually directly returning the result; before adopting this output method, it was impossible for a regex to return a value greater than the input.

The regex computes \$p-n\$, where \$n\$ is the input and \$p\$ is the next prime. To do this it takes advantage of the fact that there will always be a prime in the interval \$(n,2n]\$. Once that is complete, it outputs \$p-n+n=p\$ in the form of a number of possible matches.

 ^ # tail = N = input number
 (?=
 (?* # Non-atomic lookahead (try all options until matching)
 x(x*) # 1円 = N - (P - N), for conjectured P > N
 )
 (?! # Negative lookahead - assert that this cannot match
 (?* # Non-atomic lookahead (try all options until matching)
 (xx+) # 2円 = try all numbers from 2 through N-1
 (x+$) # 3円 = N - 2円; assert 2円 < N
 )
 (?= # Atomic lookahead (locks onto the first match)
 2円*(x+) # 4円 = N % 2,円 giving 2円 instead of 0
 )
 .*(?=3円4円$) # tail = 3円 + 4円
 1円 # tail -= 1円
 2円*$ # Assert tail is divisible by 2円
 )
 )
 1円 # tail = tail-1円 = P - N
 x+ # add tail to the number of possible matches
|
 \B # add abs(N-1) to the number of possible matches
|
 $ # add 1 to the number of the possible matches; this gets
 # us a return value of 2 for N==0, instead of 0 which we
 # would have if simply adding N instead of abs(N-1)+1

Molecular lookahead (?*...) is used for convenience. It would be possible to port to flavors that don't have it, but the regex would be much longer – it would still need to emulate arithmetic in the range \$[0,2n]\$, but would need to do so within just \$[0,n/4]\$ or perhaps \$[0,n/3]\$, instead of \$[0,n]\$ as this version does.

Without returning the correct value for \0ドル\$, this would be 65 bytes.

Regex `🐘` (.NET), (削除) 79 (削除ここまで) (削除) 77 (削除ここまで) (削除) 71 (削除ここまで) 65 bytes

(?=(x|^)+)(?<1>x|^)+?(x*$)(?<!(?=4円*(?<=(?=2円4円*$)3円))(^x+)(x+x))

Try it online!

Returns its output as the capture count of group 1円.

 # tail = N = input number
(?=(x|^)+) # 1円.captureCount = {N, if N>0, else 1}
(?<1>x|^)+? # Assert N > 0; 1円.captureCount += {N - P, if N>0, else 1}
(x*$) # 2円 = N - (N - P) = 2*N - P
(?<! # Right-to-left negative lookbehind
 (?= # Atomic lookahead
 4円* # tail = Z = N % 4,円 giving 4円 instead of 0
 (?<= # Right-to-left atomic lookbehind
 (?= # Atomic lookahead
 2円4円*$ # Assert tail-2,円 that is, 3円+Z-2,円 is divisible by 4円
 )
 3円 # tail += 3円
 )
 )
 (^x+) # 3円 = N - 4円; assert 4円 < N
 (x+x) # 4円 = try all numbers from 2 through N-1
)

Without returning a value for \0ドル\$, this would be 61 bytes.

Question 17

What do the emojis mean?

Question 18

@Bbrk24 Except for rabbit, they're animals documented to be able to count. Bee 🐝 is output via number of matches, because counting that is fairly lightweight to implement in most languages (bees are small). Elephant 🐘 is output via capture count, because that is in a way kind of overkill (elephants are big), since in .NET a capture stack contains the contents of its captures, which is potentially much more information than just the number of captures. Rabbit 🐇 is output via number of ways it can match, because rabbits multiply (breed), and this output method is great at multiplying.

Question 19

@Bbrk24 The reason I use emojis for those output methods is to differentiate them from output via the length of a string. Depending on the challenge, it can be a very different, or sometimes even impossible, to output via the length of a string instead of the count of something. Trivially it's impossible to output a number larger than the input without using a counting-style output, but also there are ones like totient function in ECMAScript where it's much more complicated and interesting to output via string length than some type of count.

Question 20

Interesting, thanks!

Question 21

Python 2, (削除) 78 (削除ここまで) (削除) 77 (削除ここまで) (削除) 76 (削除ここまで) 74 bytes

def f(n):
 while 1:
 n+=1
 if[i for i in range(1,n)if n%i<1]==[1]:return n

-1 byte thanks to @KritixiLithos
-1 byte thanks to @FlipTack
-2 bytes thanks to @ElPedro

Question 22

n%i<1 is shorter than n%i==0

Question 23

You don't need whitespace after that if.

Question 24

I think you mean <1

Question 25

@ElPedro is right. You can change the 2 spaces in front of n+=1 and if into tabs and save 2 bytes

Question 26

67 bytes by using all(..)instead of the list comprehension.

Question 27

Jelly, 2 bytes

Æn

Try it online!

This implicitly takes input z and, according to the manual, generate the closest prime strictly greater than z.

Question 28

Oasis, 2 bytes

Run with the -n flag.

Code:

Try it online!

Question 29

Bash + coreutils, 52 bytes

for((n=1,ドルn++;`factor $n|wc -w`-2;n++)){ :;};echo $n

Try it online!

The documentation for bash and factor do not specify a maximum integer value they can handle (although, in practice, each implementation does have a maximum integer value). Presumably, in the GNU of the future on your infinitely large machines, bash and factor will have unlimited size integers.

Question 30

Actually the docs do specify for factor that if built without gnu mp only single-precision is supported.

Question 31

@Dani_l Well, the man entry for bash only says: "Evaluation is done in fixed-width integers with no check for overflow, though division by 0 is trapped and flagged as an error." It doesn't specify the width. (As I recall, the stock implementations of bash on my machines use 64-bit signed integers, but I can't check right now.) As for factor, it will surely be updated: the OP's future computers with infinite resources will have factor compiled with gnu_up to get unlimited precision :).

Question 32

Brachylog, 2 bytes

<ṗ

Try it online!

Explanation

(?) < (.) Input < Output
 ṗ (.) Output is prime
 (Implicit labelization of the Output at the end of the predicate)

Question 33

Maxima, 10 bytes

next_prime

A function returns the smallest prime bigger than its argument.

Question 34

Python with sympy, 28 bytes

import sympy
sympy.nextprime

sympy.nextprime is a function which does what it says on the tin. Works for all floats.

repl.it

Python, (削除) 66 (削除ここまで) 59 bytes

-4 bytes thanks to Lynn (use -~)
-3 bytes thanks to FlipTack (use and and or, allowing ...==1 to be switched to a ...-1 condition.)

f=lambda n:sum(-~n%-~i<1for i in range(n))-1and f(n+1)or-~n

repl.it

A recursive function that counts up from n until a prime is found by testing that only one number exists up to n-1 that divides it (i.e. 1). Works for all integers, raises an error for floats.

Works on 2.7.8 and 3.5.2, does not work on 3.3.3 (syntax error due to lack of space between ==1 and else)

Question 35

(n+1)%(i+1) is -~n%-~i, I think.

Question 36

It is, thanks... I was trying to do a shorter one using Wilson's theorem.

Question 37

Does short circuiting and/or work, such as f=lambda n:sum(-~n%-~i<1for i in range(n))==1and-~n or f(n+1)?

Question 38

In fact, that ^ can be golfed to f=lambda n:sum(-~n%-~i<1for i in range(n))-1and f(n+1)or-~n

Question 39

@FlipTack I originally avoided them so it could pass through zero, but it'll work - that's a three byte save!

Question 40

Python, (削除) 114 (削除ここまで) 83 bytes

def g(b):
 while 1:
 b+=1
 for i in range(2,b):
 if b%i<1:break
 else:return b

Without builtins, if there are any.

-30 by removing whitespace and -1 by changing b%i==0 to b%i<1

Question 41

This won't find the next prime if you put in 1

Question 42

It now assumes that b>2

Question 43

You can't just make up your own rules... you need to follow the challenge specification. Nowhere does it say that you can assume the bounds of the input.

Question 44

Even with that assumption, this fails for all even valued inputs.

Question 45

I'm an idiot, i misread it. Fixed it. @FlipTack

Question 46

Perl 6, 25 bytes

{first *.is-prime,$_^..*}

How it works

{ } # A lambda.
 $_ ..* # Range from the lambda argument to infinity,
 ^ # not including the start point.
 first , # Iterate the range and return the first number which
 *.is-prime # is prime.

Perl 6, 32 bytes

{first {all $_ X%2..^$_},$_^..*}

With inefficient custom primality testing.

How it works

Outer structure is the same as above, but the predicate passed to first (to decide if a given number is prime), is now:

{ } # A lambda.
 $_ # Lambda argument (number to be tested).
 2..^$_ # Range from 2 to the argument, excluding the end-point.
 X # Cartesian product of the two,
 % # with the modulo operator applied to each pair.
 all # Return True if all the modulo results are truthy (i.e. non-0).

Question 47

I was hoping to get something shorter with Perl 5 but it's hard to beat a built-in .is-prime ;)

Question 48

Pyke, (削除) 8 (削除ここまで) 7 bytes

~p#Q>)h

Try it here!

4 bytes, noncompeting

(Interpreter updated since challenge posted)

~p<h

Try it here!

~p - primes_iterator()
 < - filter(^, input() < i)
 h - ^[0]

Question 49

Why's the second noncompeting? I don't understand enough.

Question 50

@theonlygusti: Typically, the only legitimate reason to mark a submission noncompeting here (as opposed to not submitting it at all) is because you fixed a bug or added a feature in the language the program's written in, and that helped you with the challenge. (I tend to write it as "language postdates challenge" to be more clear.)

Question 51

@theonlygusti clarified

Question 52

Lua, 876 Bytes

function I(a)a.s=a.s:gsub("(%d)(9*)$",function(n,k)return tostring(tonumber(n)+1)..("0"):rep(#k)end)end function D(a)a.s=a.s:gsub("(%d)(0*)$",function(n,k)return tostring(tonumber(n)-1)..("9"):rep(#k)end):gsub("^0+(%d)","%1")end function m(a,b)local A=K(a)local B=K(b)while V(0,B)do D(A)D(B)end return A end function M(a,b)local A=K(a)local B=K(b)while V(m(B,1),A)do A=m(A,B)end return A end function l(n)return#n.s end function p(a)local A=K(a)local i=K(2)while V(i,A)do if V(M(A,i),1)then return false end I(i)end return true end function V(b,a)A=K(a)B=K(b)if l(A)>l(B)then return true end if l(B)>l(A)then return false end for i=1,l(A)do c=A.s:sub(i,i)j=B.s:sub(i,i)if c>j then return true elseif c<j then return false end end return false end function K(n)if(type(n)=='table')then return{s=n.s}end return{s=tostring(n)}end P=K(io.read("*n"))repeat I(P)until p(P)print(P.s)

Lua, unlike some other languages, does have a Maximum Integer Size. Once a number gets larger than 2³², things stop working correctly, and Lua starts trying to make estimates instead of exact values.

As such, I had to implement a new method of storing numbers, in particular, I've stored them as Base10 strings, because Lua doesn't have a size limit on Strings, other than the size of the memory.

I feel this answer is much more to the Spirit of the question, as it has to itself implement arbitrary precision integers, as well as a prime test.

Explained

-- String Math
_num = {}
_num.__index = _num
-- Increase a by one.
-- This works by grabbing ([0-9])999...$ from the string.
-- Then, increases the first digit in that match, and changes all the nines to zero.
-- "13", only the "3" is matched, and it increases to 1.
-- "19", firstly the 1 is turned to a 2, and then the 9 is changed to a 0.
-- "9" however, the 9 is the last digit matched, so it changes to "10"
function _num.inc(a)
 a.str = a.str:gsub("(%d)(9*)$",function(num,nines)
 return tostring(tonumber(num)+1)..("0"):rep(#nines)
 end)
end
-- Decrease a by one
-- Much like inc, however, uses ([0-9])0...$ instead.
-- Decrements ([0-9]) by one and sets 0... to 9...
-- "13" only the "3" is matched, and it decreases by one.
-- "10", the "1" is matched by the ([0-9]), and the 0 is matched by the 0..., which gives 09, which is clipped to 9.
function _num.dec(a)
 a.str = a.str:gsub("(%d)(0*)$",function(num,zeros)
 return tostring(tonumber(num)-1)..("9"):rep(#zeros)
 end) :gsub("^0+(%d)","%1")
end
-- Adds a and b
-- Makes A and B, so that the original values aren't modified.
-- B is then decremented until it hits 0, and A is incremented.
-- A is then returned.
function _num.__add(a,b)
 local A = str_num(a)
 local B = str_num(b)
 while B > 0 do
 A:inc()
 B:dec()
 end
 return A
end
-- Subs b from a
-- Works just like Addition, yet Dec's A instead of Incs.
function _num.__sub(a,b)
 local A = str_num(a)
 local B = str_num(b)
 while B > 0 do
 A:dec()
 B:dec()
 end
 return A
end
-- A % B
-- Makes A and B from a and b
-- Constantly subtracts B from A until A is less than B
function _num.__mod(a,b)
 local A = str_num(a)
 local B = str_num(b)
 while A >= B do
 A = A - B
 end
 return A
end
-- #a
-- Useful for golfiness
function _num.__len(n)
 return #n.str
end
-- Primacy Testing
-- Generates A from a and i from 2.
-- Whilst i is less than A, i is incremented by one, and if A % i == 0, then it's not a prime, and we return false.
-- Once that finishes, we return true.
function _num.isprime(a)
 local A = str_num(a)
 local i = str_num(2)
 while i < A do
 if A%i < 1 then
 return false
 end
 i:inc()
 end
 return true
end
-- b < a
-- A and B are generated from a and b
-- Fristly, if the length of A and B aren't equal, then that result is output.
-- Otherwise, each character is searched from left to right, the moment they are unequal, the difference is output.
-- If all the characters match, then it's equal. Return false.
function _num.__lt(b,a)
 A=str_num(a)
 B=str_num(b)
 if #A > #B then
 return true
 end
 if #B > #A then
 return false
 end
 for i=1, #A.str do
 As = A.str:sub(i,i)
 Bs = B.str:sub(i,i)
 if As > Bs then
 return true
 elseif As < Bs then
 return false
 end
 end
 return false
end
-- b <= a
-- Same as b < a, but returns true on equality.
function _num.__le(b,a)
 A=str_num(a)
 B=str_num(b)
 if #A > #B then
 return true
 end
 if #B > #A then
 return false
 end
 for i=1, #A.str do
 As = A.str:sub(i,i)
 Bs = B.str:sub(i,i)
 if As > Bs then
 return true
 elseif As < Bs then
 return false
 end
 end
 return true
end
-- Just straight up returns it's string component. Endlessly faster than the int equivalent, mostly because it never is anything _but_ the string form.
function _num.__tostring(a)
 return a.str
end
-- Just set up the metatable...
function str_num(n)
 if(type(n)=='table')then
 return setmetatable({str = n.str}, _num)
 end
 return setmetatable({str = tostring(n)}, _num)
end
-- Generate a new str_num from STDIN
Prime = str_num(io.read("*n"))
-- This is handy, because it will call Prime:inc() atleast once, and stop at the next prime number it finds.
-- Basically, if it weren't for all that overhead of making the math possible, that's all this would be.
repeat
 Prime:inc()
until Prime:isprime()
print(Prime)

Although the above uses Metatables, instead of just regular functions like the actual answer, which worked out smaller.

Question 53

Vyxal, 2 bytes

∆Ṗ

Try it Online!

Here for completeness. Like answers in many other golfing langs, ∆Ṗ is simply a builtin for "next prime greater than n". It uses sympy.nextprime from Python's sympy library to do this

Question 54

J, 4 bytes

4&p:

Simple built in for next prime.

Question 55

05AB1E, (削除) 16 (削除ここまで) 13 bytes (Emigna @ -3 bytes)

2•7£?ÿ•o[>Dp#

Try it online!

2•7£?ÿ•o # Push current largest prime.
 [ # # Until true..
 >Dp # Increment by 1, store, check primality.
 # After infinite loop, implicitly return next prime.

Question 56

Wouldn't [>Dp# work?

Question 57

You can still cut 8 more bytes as the program should take a prime as input and output the next prime.

Question 58

@Emigna then this question is a duplicate.

Question 59

That is probable yes.

Question 60

Perl, 30 bytes (29 +1 for `-p`):

(1x++$_)=~/^(11+?)1円+$/&&redo

Usage

Input the number after pressing return (input 12345 in example below, outputs 12347):

$ perl -pe '(1x++$_)=~/^(11+?)1円+$/&&redo'
12345
12347

How it works

Define a string of 1's that has length ++$_, where $_ is initially the input value
The regex checks to see if the string of 1s is non-prime length (explained here).
If the string length is non-prime, the check is re-evaluated for the next integer (++$_)
If the string length is prime, the implicit while loop exits and -p prints the value of $_
Note: there is no need to handle the edge case "1" of length 1 because it will never be used for values less than 1, per the specification.

Question 61

Java 7, (削除) 373 (削除ここまで) (削除) 343 (削除ここまで) (削除) 334 (削除ここまで) (削除) 303 (削除ここまで) 268 bytes

import java.math.*;class M{public static void main(String[]a){BigInteger n,i,o,r=new BigInteger(a[0]);for(r=r.add(o=r.ONE);;r=r.add(o)){for(n=r,i=o.add(o);i.compareTo(n)<0;n=n.mod(i).compareTo(o)<0?r.ZERO:n,i=i.add(o));if(n.compareTo(o)>0)break;}System.out.print(r);}}

-75 bytes thanks @Poke

Ungolfed:

import java.math.*;
class M{
 public static void main(String[] a){
 BigInteger n,
 i,
 o,
 r = new BigInteger(a[0]);
 for(r = r.add(o = r.ONE); ; r = r.add(o)){
 for(n = r, i = o.add(o); i.compareTo(n) < 0; n = n.mod(i).compareTo(o)< 0
 ? r.ZERO
 : n,
 i = i.add(o));
 if(n.compareTo(o) > 0){
 break;
 }
 }
 System.out.print(r);
 }
}

Try it here.

Some example input/outputs:

7 -> 11
1609 -> 1613
104723 -> 104729

Question 62

@Poke I've golfed another 31 bytes by adding static for the field and method p, but removing method c and p's parameter.

Question 63

05AB1E, 2 bytes

ÅN

Try it online!

ÅN # full program
ÅN # push smallest prime greater than...
 # implicit input
 # implicit output

Question 64

Pyth, 5 bytes

fP_Th

Try it online!

Explanation:

f # first integer greater than or equal to
 hQ # input + 1
 P_T # which is prime

Greg Martin 16.7k4 gold badges23 silver badges73 bronze badges · Accepted Answer · 2017-01-29 10:45:06Z

25

\$\begingroup\$

Mathematica, 9 bytes

NextPrime

Share

Improve this answer

answered Jan 29, 2017 at 10:45

Greg Martin's user avatar

Greg Martin

16.7k4 gold badges23 silver badges73 bronze badges

\$\endgroup\$

3

\$\begingroup\$ ... Does this actually work? \$\endgroup\$

wizzwizz4
– wizzwizz4

2017年01月29日 15:40:22 +00:00
Commented Jan 29, 2017 at 15:40
13

\$\begingroup\$ Of course, Mathematica always has a builtin \$\endgroup\$

JungHwan Min
– JungHwan Min

2017年01月29日 15:41:21 +00:00
Commented Jan 29, 2017 at 15:41
\$\begingroup\$ @wizzwizz4, sure, Try it online! \$\endgroup\$

Pavel
– Pavel

2017年01月29日 18:23:40 +00:00
Commented Jan 29, 2017 at 18:23

Add a comment |

The program that will find the next prime number

Intro:

Challenge:

35 Answers 35

Mathematica, 9 bytes

Python 3, 45 bytes

Regex 🐇 (PCRE2 v10.35 or later), (削除) 80 (削除ここまで) (削除) 77 (削除ここまで) 69 bytes

Regex 🐘 (.NET), (削除) 79 (削除ここまで) (削除) 77 (削除ここまで) (削除) 71 (削除ここまで) 65 bytes

Python 2, (削除) 78 (削除ここまで) (削除) 77 (削除ここまで) (削除) 76 (削除ここまで) 74 bytes

Jelly, 2 bytes

Oasis, 2 bytes

Bash + coreutils, 52 bytes

Brachylog, 2 bytes

Explanation

Maxima, 10 bytes

Python with sympy, 28 bytes

Python, (削除) 66 (削除ここまで) 59 bytes

Python, (削除) 114 (削除ここまで) 83 bytes

Perl 6, 25 bytes

How it works

Perl 6, 32 bytes

How it works

Pyke, (削除) 8 (削除ここまで) 7 bytes

4 bytes, noncompeting

Lua, 876 Bytes

Explained

Vyxal, 2 bytes

J, 4 bytes

05AB1E, (削除) 16 (削除ここまで) 13 bytes (Emigna @ -3 bytes)

Perl, 30 bytes (29 +1 for -p):

Java 7, (削除) 373 (削除ここまで) (削除) 343 (削除ここまで) (削除) 334 (削除ここまで) (削除) 303 (削除ここまで) 268 bytes

05AB1E, 2 bytes

Pyth, 5 bytes

Husk, (削除) 4 (削除ここまで) 3 bytes

Java, 176 Bytes

Vyxal, 40 bits1, 5 bytes

Explained

Vyxal, 52 bits1, 6.5 bytes

Nekomata -1, 3 bytes

Explanation

Thunno 2, 3 bytes

Explanation

QBIC, 34 bytes

JavaScript (ES7), 61 bytes

Usage

Output

MATL, 3 bytes

Haskell, (削除) 42 (削除ここまで) (削除) 46 (削除ここまで) 43 bytes

Your Answer

Sign up or log in

Post as a guest

Post as a guest

Linked

Related

Hot Network Questions

Regex `🐇` (PCRE2 _{^{v10.35 or later}}), (削除) 80 (削除ここまで) (削除) 77 (削除ここまで) 69 bytes

Regex `🐘` (.NET), (削除) 79 (削除ここまで) (削除) 77 (削除ここまで) (削除) 71 (削除ここまで) 65 bytes

Perl, 30 bytes (29 +1 for `-p`):

Vyxal, 40 bits¹, 5 bytes

Vyxal, 52 bits¹, 6.5 bytes

Nekomata `-1`, 3 bytes