51
\$\begingroup\$

Task

Given a non-negative integer n, output 1 if n is 0, and output the value of n otherwise.

Input

A non-negative integer.

  • If you would like to accept the string as input, the string would match the following regex: /^(0|[1-9][0-9]*)$/, i.e. it must not have any leading zeroes, except when it is 0.
  • If you accept a real integer as input, you may assume that the integer is within the handling capability of the language.

Output

A positive integer, specified above. Leading zeroes are not allowed. Your output should match the regex /^[1-9][0-9]*$/.

Testcases

input output
    0      1
    1      1
    2      2
    3      3
    4      4
    5      5
    6      6
    7      7

Scoring

This is , so shortest answer in bytes wins.

Standard loopholes apply.

\$\endgroup\$
7
  • 1
    \$\begingroup\$ You should probably put a link to the TNB CMC, since that's where this challenge came from. \$\endgroup\$
    – mbomb007
    May 3, 2017 at 20:53
  • \$\begingroup\$ Does the answer need to be a full function, or can it be the body? \$\endgroup\$ May 3, 2017 at 20:58
  • 1
    \$\begingroup\$ @CalebKleveter The default rule in PPCG is that the answer is either a function or a full program, but not snippets. \$\endgroup\$
    – Leaky Nun
    May 4, 2017 at 1:56
  • \$\begingroup\$ Can we print the output with a leading zero? \$\endgroup\$
    – MD XF
    Dec 26, 2017 at 21:54
  • \$\begingroup\$ @MDXF yes, you can. \$\endgroup\$
    – Leaky Nun
    Dec 26, 2017 at 22:30

146 Answers 146

1
\$\begingroup\$

AWK, 10 bytes

!$0{$0=1}1

Try it online!

Example Usage:

awk '!$0{$0=1}1' <<< 978
\$\endgroup\$
1
\$\begingroup\$

Universal lambda, 3 bytes (17 bits)

00010110001100010

It is a function and not a complete program. I think it should work, but didn't actually test it because it doesn't seem easy to do so. It means λx.x(λy.x)(λy.y).

Lazy K, 10 bytes

S(SIK)(KI)

It is a function, untested, too.

\$\endgroup\$
1
\$\begingroup\$

05AB1E, 7 bytes

D0›i,}1

Try it online!

D           //push two inputs (implicit)
 0›         //push input greater than zero
   i        //if true
    ,}      //print input
      1     //push 1. printing is implicit if there is no previous output
\$\endgroup\$
4
  • \$\begingroup\$ I'm sure there is a much shorter way to do this... \$\endgroup\$
    – Leaky Nun
    May 2, 2017 at 18:56
  • \$\begingroup\$ Me too, but I can't actually work 05ab1e, so... \$\endgroup\$
    – osuka_
    May 2, 2017 at 18:57
  • \$\begingroup\$ You could save 3 bytes with D_i1. \$\endgroup\$
    – Emigna
    May 2, 2017 at 20:25
  • 3
    \$\begingroup\$ Or in two bytes: $M. \$\endgroup\$
    – Adnan
    May 2, 2017 at 21:51
1
\$\begingroup\$

Brain-Flak, 14 bytes

((){{}[()]}{})

Try it online!

Just computes: 1 + (n ? n-1 : 0).

\$\endgroup\$
1
1
\$\begingroup\$

Whirl, 38 bytes

01100011100011110011111100001000111100

Try it online!

Explanation:

01100     op.ccw, op.intio    Mem1 = STDIN
011100    math.ccw, math.=    If (Mem1 = 0) Then (Math.Val = 1) Else (Math.Val = 0)
0111100   op.cw, op.one       Op.Val=1
11111100  math.add            Math.Val = Math.Val + Mem1
00        op.one              Op.Val=1 (Cheapest way to loop back to the Math wheel)
100       math.store          Mem1 = Math.Val
0111100   op.ccw, op.intio    STDOUT = Mem1
\$\endgroup\$
1
\$\begingroup\$

Ohm, 11 6 bytes

ö?┼¿1;

Uses CP-437 character encoding. Run with -c flag

Explanation:

ö?┼¿1;
       ■print(                                            )
  ┼    ■      first_input()
 ?   ; ■                   if(                     )
ö      ■                      int(first_input())!=0
   ¿   ■                                            else 
    1  ■                                                 1
\$\endgroup\$
3
  • \$\begingroup\$ Here's a list of things you could fix: (1) if you just say this is in CP437 (no need for the -c flag), you only need to count characters. (2) Ohm is written in Ruby, so 0 is a truthy value. However, there is a built-in x != 0 component (ö). (3) There is implicit printing, so , is not necessary. (4) Ohm is on TIO now, so it'd help if you added a link to it. \$\endgroup\$ May 2, 2017 at 19:57
  • \$\begingroup\$ FYI, feel free to ping me in chat if you have any questions about/feature reqs for the language! \$\endgroup\$ May 2, 2017 at 20:11
  • \$\begingroup\$ Again, there's no need for the -c flag. That's just for reading files; it's not necessary for PPCG submissions. Just say it's in CP437 and you're good. \$\endgroup\$ May 2, 2017 at 20:36
1
\$\begingroup\$

Java, 29 bytes

Try Online

int f(int n){return n<1?1:n;}
\$\endgroup\$
1
\$\begingroup\$

Japt, 2 bytes

w1

Try it online!

Returns the larger of 1 and the input.

\$\endgroup\$
1
\$\begingroup\$

C++, 22 bytes

[](int i){return!i+i;}

Try it online

\$\endgroup\$
1
\$\begingroup\$

Excel, 10 bytes

=MAX(A1,1)

Here's another 10-byte solution: link

\$\endgroup\$
1
\$\begingroup\$

SpecBAS - 20 bytes

1 INPUT n: ?n OR n=0

? is shorthand for PRINT

\$\endgroup\$
1
\$\begingroup\$

C#, 11 bytes

n=>n<1?1:n;

This compiles to a Func<int, int>.

\$\endgroup\$
1
\$\begingroup\$

Starry, 14 bytes

, +'      +*`.

Try it online!

Explanation

Space shown as _ .

,           Read integer and push to stack
_+          Duplicate
'           If non-zero jump to branch label
______+     Push 1
*           Add
`           Mark branch label
.           Print as a number
\$\endgroup\$
1
  • \$\begingroup\$ My first Starry answer \$\endgroup\$
    – Luis Mendo
    May 2, 2017 at 23:10
1
\$\begingroup\$

Clojure, 12 bytes

#(get[1]% %)

The get function takes an associative data structure, a key, and a default value. Vectors are associative using sequential position as the key. So, [1] is a vector with the value 1 at position 0. If get is called with parameter 0 it will return 1, otherwise no other keys exist in the vector so it returns the default value of the parameter.

\$\endgroup\$
1
\$\begingroup\$

Desmos, 13 bytes

f(x)=max(x,1)

Try it here

\$\endgroup\$
1
  • \$\begingroup\$ Desmos tips: you can have lists of integers like this. \$\endgroup\$
    – Leaky Nun
    May 4, 2017 at 1:58
1
\$\begingroup\$

Clojure, 10 bytes

#(max 1%)

Not much to explain.

\$\endgroup\$
1
  • \$\begingroup\$ I think you can shorten this to #(max 1%) (9 bytes). tio.run/nexus/… \$\endgroup\$
    – Dennis
    May 4, 2017 at 14:37
1
\$\begingroup\$

Julia, 13 12 bytes

f(n)=n<1?1:n

Unfortunately, Julia doesn't do implicit casting from int to bool, so I have to burn an entire 3 characters just to do a comparison to zero. Saved one byte by safely assuming the number isn't negative. Still too verbose for my taste, though.

\$\endgroup\$
1
  • \$\begingroup\$ You can post the answer as an anonymous function and save 2 bytes, n->n<1?1:n Try it online! \$\endgroup\$
    – Sundar R
    Aug 12, 2018 at 21:16
1
\$\begingroup\$

Groovy, 7 bytes

{it?:1}

Elvis operator; if true, return self, else return 1. Only false integer value auto-unboxxed to false in Groovy is 0. Thusly, exactly the spec.

\$\endgroup\$
1
\$\begingroup\$

Symbolic Python, 11 bytes

_+=_==(_>_)

Try it online!

_+=           # Output = Input +
   _==(_>_)                       Input == 0
\$\endgroup\$
1
\$\begingroup\$

Google Sheets, 9 Bytes

Anonymous worksheet function that takes input from range A1 and outputs to the calling cell

=Max(1,A1
\$\endgroup\$
1
  • \$\begingroup\$ This look very cool mate :) \$\endgroup\$
    – NTCG
    Jan 4, 2018 at 8:07
1
\$\begingroup\$

Bash, 43 bytes

if [ $1 -eq 0 ];then echo 1;else echo $1;fi
\$\endgroup\$
1
\$\begingroup\$

Python 21 Bytes

int(max('1',input()))

Takes input from REPL environment

\$\endgroup\$
1
\$\begingroup\$

Aceto, 9 8 bytes

rid0=`1p

read an integer and duplicate it, then push 0. Are they =? Then (`) push a 1. print the top element.

\$\endgroup\$
1
\$\begingroup\$

PowerShell, 24 22 17 Bytes

blatantly stolen from here

!($a=$args[0])+$a

Explanation

Invert the value, returning 0 for non-0 numbers, and 1 for 0, then add the intitial to it.

this makes it basically 1/0 + value, so for 0 the first value is 1, any other numbers it's 0.

examples:
# !0+0 = 1
# !1+1 = 1
# !9+9 = 9
\$\endgroup\$
3
  • 1
    \$\begingroup\$ Could you instead use !$a as your index check? You wouldn't be able to set $a in your current manner, but I think something like this would work? Try it online! \$\endgroup\$
    – Sinusoid
    May 2, 2017 at 21:13
  • 1
    \$\begingroup\$ @Sinusoid that worked perfectly for -2, but turns out the C answer was a bit ahead of us both, didn't think of the method at all. \$\endgroup\$
    – colsw
    May 3, 2017 at 9:46
  • \$\begingroup\$ That is certainly interesting! I will need to keep this method in mind :P \$\endgroup\$
    – Sinusoid
    May 3, 2017 at 13:21
1
\$\begingroup\$

Chip, 20 18 bytes

eaABb
*`\\-!
fcCDd

Try it online!

How?

 aABb
            Copy the low 4 bits from input to output
 cCDd

e
*           Set the higher bits of output, so that the values are ASCII digits
f

eaABb
*           Replicate any ASCII digits on input to output
fcCDd

            -
     !      Produce a high signal, but only during the first byte
            -

 aAB
 `\\-*      Set the lowest bit of output, if the four low bits of input are unset
  CD

 aAB        Set the lowest bit of output, if the four low bits
 `\\-!      of input are unset, and only on the first byte
  CD
\$\endgroup\$
1
\$\begingroup\$

Julia 0.6, 10 bytes

x->x<1?1:x

Try it online!

\$\endgroup\$
1
  • 1
    \$\begingroup\$ also 10 bytes: x->x+(x<1) \$\endgroup\$
    – Giuseppe
    Jan 17, 2018 at 19:03
1
\$\begingroup\$

SNOBOL4 (CSNOBOL4), 49 47 36 bytes

	N =INPUT
	N =EQ(N) 1
	OUTPUT =N
END

Try it online!

\$\endgroup\$
1
\$\begingroup\$

><>, 6 bytes

:?!1n;

Could have been 1 byte shorter if ? had the opposite conditional behaviour.

:?       check if nonzero, then either
  !      a) skip the next instruction or
   1     b) push 1 to the stack
    n    print
     ;   terminate
\$\endgroup\$
3
  • \$\begingroup\$ Take the input via the -v flag instead. It saves a byte, and it's less suspect than using the char code of a character \$\endgroup\$
    – Jo King
    Apr 13, 2018 at 8:17
  • \$\begingroup\$ 5 bytes \$\endgroup\$
    – Jo King
    Apr 13, 2018 at 10:34
  • \$\begingroup\$ Terminating with an error wasn't legal when I used to be around. \$\endgroup\$ Apr 13, 2018 at 12:14
1
\$\begingroup\$

JavaScript (Node.js), 10 bytes

n=>n&&n||1

Try it online!

here is one more

JavaScript (Node.js), 8 bytes

n=>n?n:1

Try it online!

and lastly

JavaScript (Node.js), 7 bytes

n=>n||1

Try it online!

\$\endgroup\$
1
  • \$\begingroup\$ From the BASIC answer n=>n+!n (also 7 bytes) should also work ;) \$\endgroup\$ Sep 6, 2019 at 5:39
1
\$\begingroup\$

BitCycle, 8 7 bytes

-1 byte thanks to Jo King

?v<
!+~

Try it online!

Uses the -U flag to convert decimal inputs to "signed unary," which in this case means unary for positive integers and 0 for zero.

How it works

Let's run two example inputs: 3 and 0.

An input of 3 gets converted to 111 and emerges from the source (?) moving east. It follows the arrow down to the +, where the 1 bits turn right (west). They fall into the sink (!) and are converted back to decimal 3 and output.

An input of 0 gets converted to 0. When the 0 bit reaches the +, it turns left into the dupneg (~). Here the 0 turns right (south, off the playfield) and a negated copy of it turns left (north). This negated copy, being a 1 bit, goes back around to the + and turns right. It falls into the sink, is converted to decimal 1, and is output.

\$\endgroup\$
0

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.