Communities

Writing
Writing
Codidact Meta
Codidact Meta
The Great Outdoors
The Great Outdoors
Photography & Video
Photography & Video
Scientific Speculation
Scientific Speculation
Cooking
Cooking
Electrical Engineering
Electrical Engineering
Judaism
Judaism
Languages & Linguistics
Languages & Linguistics
Software Development
Software Development
Mathematics
Mathematics
Christianity
Christianity
Code Golf
Code Golf
Music
Music
Physics
Physics
Linux Systems
Linux Systems
Power Users
Power Users
Tabletop RPGs
Tabletop RPGs
Notifications
Mark all as read
Challenges

Can you give me half?

+10
−0

Challenge idea taken from: Eliseo D'Annunzio

Task

Provide code that evaluates to 0.5 numerically, i.e. the output must be recognized by your chosen language as a numeric value (Number, float, double, etc), not as a string.

The catch, the characters 0 through to 9 cannot be used.

One example that fits the brief would be the following:

((++[[]][[~~""]]<<++[[]][[~~""]]))**((--[[]][[~~""]])) which works out to 0.5 in JavaScript.

Scoring

This is a code challenge, where scoring is done in terms of number of unique characters used in the submission. Ties are broken by lowest bytecount.

Why does this post require moderator attention?
You might want to add some details to your flag.
Why should this post be closed?

0 comment threads

20 answers

+5
−0

dc, 3 unique bytes, 138 bytes

This challenge is pretty easy if you aim for just 4 unique bytes. For example, you could push the stack depth repeatedly to get ascending integers, set the precision to something positive, divide and then print.

zzzzk/p

And surely it can't go any lower, right? After all, we have to increase the precision (k), print (p, n, f), do a floating-point operation (v, ^, /, .), and still get a number from somewhere...

Luckily though, there is actually a narrow path forward thanks to a and x. a pops a number off the stack, casts it to a long, and pushes its LSB back as a single-character string. Using x we can then execute that string as a command. This leaves us to choose a third command which should give us some helpful numbers that we can feed into a. The only options that can give us a range of numbers are z as well as the hex digits A through F. I haven't found a way to tame z, since it buries every intermediate result you get, so let's just see what useful characters we can get if we choose one of the hex digits.

Program Resulting character
AAa n
AAAAa f
AAAAAAa F
CCCa 4
DDDDa k
FFFFFFa i

At first, this might not look too promising, but if we choose F as our third command, we can use the i to change the input base to 15 and basically get a reroll on our commands. 🤞

Program Resulting character
FxFFFFFFaxFFFFFa /
FxFFFFFFaxFFFFFFFa ?

The ? doesn't help us, since we don't get any input, the / however is game-changing. By carefully placing the right constants on the stack before and after the base change we can later use / to efficiently calculate the ASCII value of any command. We use this to first set the precision to 15 and then sum, divide and print three pre-placed Fs (as in F k F F F + / n) to do the actual calculation.

Finally, here is an annotated version of the complete program:

F F F         # three 15s for calculating 0.5
FFFFFFFFFFFFF # "+" numerator
FFFFFF        # "+" denominator 1
F             # argument for k
FFFFFFFFFFF   # "k" numerator
FFFFF         # "k" denominator 1
F             # argument for i
FFFFFFax      # execute "i" to switch base
FFFFFax       # "k" division 1
F             # "k" denominator 2
FFFFFax       # "k" division 2
ax            # execute "k" to set precedence
FFFFFax       # "+" division 1
F             # "+" denominator 2
FFFFFax       # "+" division 2
ax            # execute "+" to add two 15s
FFFFFax       # divide 15 by 30
FFFFFFFFFFFF  # "n" numerator 1
FFF           # "n" denominator 1
FFFFFax       # "n" division 1
FFFF          # "n" denominator 2
FFFFFax       # "n" division 2
ax            # execute "n" to print the result

We can get rid of any whitespace by placing xs between constants since they act as no-ops on numbers.

FxFxFxFFFFFFFFFFFFFxFFFFFFxFxFFFFFFFFFFFxFFFFFxFxFFFFFFaxFFFFFaxFxFFFFFaxaxFFFFFaxFxFFFFFaxaxFFFFFaxFFFFFFFFFFFFxFFFxFFFFFaxFFFFxFFFFFaxax

Try it online!

Why does this post require moderator attention?
You might want to add some details to your flag.

0 comment threads

+4
−0

Embed ESCR, 6 unique characters, 19 bytes

[/ [*] [+ [*] [*]]]

Each [] pair of brackets encloses an in-line function. The first token in a function is the function name, and subsequent tokens, if any, the parameters. Functions can be nested.

The * function multiplies a series of numbers. The product is initialized to 1 before the first term. A side-effect is that just "*" without any parameter returns 1. The "+" function adds two 1s to make 2. The "/" function divides the first parameter by the second, so 1 divided by 2. The result is 1/2.

The spaces are enforced for readability, and to simplify the parsing rules. This NOT a golfing language.

Why does this post require moderator attention?
You might want to add some details to your flag.

1 comment thread

comment (1 comment)
+3
−0

Ruby, 7 unique, 12 bytes

$$.fdiv$$+$$

Ruby, 8 unique, 13 bytes:

$$.fdiv $$+$$

Ruby, 9 unique, 22 bytes:

"i".size.fdiv"ii".size

Ruby, 9 unique, 24 bytes:

Math::E./Math::E+Math::E

Why does this post require moderator attention?
You might want to add some details to your flag.

0 comment threads

+3
−0

J, 4 3 distinct, 6 bytes

-:_-:_

Half of _ -: _ which is asks if infinity matches infinity. Thanks to @xash in the APL farm discord for saving the 3 unique bytes and orthoplex for catching my blunder.

Why does this post require moderator attention?
You might want to add some details to your flag.

1 comment thread

`%#_ _` has unique 4 bytes, no? (2 comments)
+3
−0

C (gcc), 8 7 unique

cos(cos-cos)/(cos(cos-cos)-(-cos(cos-cos)))

Try it online!

-1 unique character thanks to @orthoplex‭

Why does this post require moderator attention?
You might want to add some details to your flag.

1 comment thread

golf (2 comments)
+3
−0

Python 3, 7 distinct characters, 11 bytes

True/-~True

Try it online!

Why does this post require moderator attention?
You might want to add some details to your flag.

0 comment threads

+3
−0

Clojure - 15 characters total, 5 unique

Inspired by the Embed ESCR solution above, I realized I could do something very similar in Clojure:

(/(*)(+(*)(*)))

This returns 1/2, which is a Ratio in Clojure.

(*) - * with no arguments returns 1.

(+...) - + returns the sum of its arguments

(/...) - / divides the first argument by the second, returning a Ratio.

Why does this post require moderator attention?
You might want to add some details to your flag.

0 comment threads

+3
−0

Perl, 3 distinct, 12 bytes

s//yy//y/y//

Try it online!

Prepends yy to the start of $_, and then transliterates them, dividing the count of each.

Why does this post require moderator attention?
You might want to add some details to your flag.

0 comment threads

+2
−0

Ruby, 10 distinct, 35 chars

t=/%/=~%/=%/
o=/%/=~%/==%/
t/o.to_f
Why does this post require moderator attention?
You might want to add some details to your flag.

0 comment threads

+2
−0

Japt, 1 byte

½

Test it

Jelly, Vyxal, 1 byte

.

Try it online!

Yeah, golf langs still kind of kill this challenge.

Why does this post require moderator attention?
You might want to add some details to your flag.

1 comment thread

I think the second works in 05AB1E too (3 comments)
+2
−0

Javascript, 5 Distinct characters, 9 Bytes

~[]/~-~[]

Why does this post require moderator attention?
You might want to add some details to your flag.

0 comment threads

+2
−0

Scala, 15 bytes

'#'.toFloat/'F'

Try it in Scastie!

Characters in Scala kinda get casted to integers. This is usually annoying, but it's useful when golfing. # is 35 and F is 70, and the .toFloat prevents it from doing integer division and truncating to 0.

Why does this post require moderator attention?
You might want to add some details to your flag.

0 comment threads

+2
−0

JS, 15 bytes

!![]/(-~[]-~[])

Basically typed random characters into js console and it worked.

Why does this post require moderator attention?
You might want to add some details to your flag.

0 comment threads

+2
−0

Julia 1.0, 16 bytes

(o=one(Int))/-~o

Try it online!

Why does this post require moderator attention?
You might want to add some details to your flag.

0 comment threads

+2
−0

Raku (also Perl polyglot), 5 unique, 13 bytes

!()/(!()+!())

() or empty list coerces to its length which is 0 in math operations and !0 is True which coerces to 1

Why does this post require moderator attention?
You might want to add some details to your flag.

0 comment threads

+2
−0

Lua 5.4, 3 unique characters

#'#'/#'##'

Try it online!

[...] scoring is done in terms of number of unique characters used in the submission.

  1. Hashtag #
  2. Single quote '
  3. Slash /
Why does this post require moderator attention?
You might want to add some details to your flag.

0 comment threads

+2
−0

Python 3, 5 unique bytes, 28 total

(()==())/((()==())+(()==()))

(, ), =, /, +

Uses (()==()) to get True with only 3 unique characters, as well as making the later grouping of (...+...) free.

Try it online!

Why does this post require moderator attention?
You might want to add some details to your flag.

0 comment threads

+1
−0

J, 4 unique, 4 char

-:=_

How it works:

-: results in half of what's on the right
= results in signum of what's on the right
_ is infinity
Why does this post require moderator attention?
You might want to add some details to your flag.

0 comment threads

+1
−0

MATL, 3 distinct, 3 total

lH/

Try it online!

Computes 1/2. Reserved labels for constants can be found here

Why does this post require moderator attention?
You might want to add some details to your flag.

0 comment threads

+0
−0

Fig, 3 distinct, 3 total

HLQ

Try it online!

Halves the length of str(0).

Why does this post require moderator attention?
You might want to add some details to your flag.

0 comment threads

Sign up to answer this question »

This community is part of the Codidact network. We have other communities too — take a look!

You can also join us in chat!

Want to advertise this community? Use our templates!

Like what we're doing? Support us! Donate