text:
Print all lexicographically increasing numbers under 10000
A lexicographically increasing number is an integer whose digits are in strictly increasing order. Print all lexicographically increasing numbers under 10000.
Here are lines of the expected output:
0
1
2
3
4
5
6
7
8
9
12
13
14
15
16
17
18
19
23
24
25
26
27
28
29
34
35
36
37
38
39
45
46
47
48
49
56
57
58
59
67
68
69
78
79
89
123
124
125
126
127
128
129
134
135
136
137
138
139
145
146
147
148
149
156
157
158
159
167
168
169
178
179
189
234
235
236
237
238
239
245
246
247
248
249
256
257
258
259
267
268
269
278
279
289
345
346
347
348
349
356
357
358
359
367
368
369
378
379
389
456
457
458
459
467
468
469
478
479
489
567
568
569
578
579
589
678
679
689
789
1234
1235
1236
1237
1238
1239
1245
1246
1247
1248
1249
1256
1257
1258
1259
1267
1268
1269
1278
1279
1289
1345
1346
1347
1348
1349
1356
1357
1358
1359
1367
1368
1369
1378
1379
1389
1456
1457
1458
1459
1467
1468
1469
1478
1479
1489
1567
1568
1569
1578
1579
1589
1678
1679
1689
1789
2345
2346
2347
2348
2349
2356
2357
2358
2359
2367
2368
2369
2378
2379
2389
2456
2457
2458
2459
2467
2468
2469
2478
2479
2489
2567
2568
2569
2578
2579
2589
2678
2679
2689
2789
3456
3457
3458
3459
3467
3468
3469
3478
3479
3489
3567
3568
3569
3578
3579
3589
3678
3679
3689
3789
4567
4568
4569
4578
4579
4589
4678
4679
4689
4789
5678
5679
5689
5789
6789

This is a code golf challenge! Shortest answer wins!
(P.S. looking for a python solution)

do we need to print them on separate lines or is space-separated OK?

Welcome to PPCG! Nice first challenge. For future challenges, I can recommend using the Sandbox to refine a challenge and get meaningful feedback before posting it to main.

To expand on @Giuseppe's question, can we output separated by commas, spaces, in array format [0,1,...], etc. or must we output each number on a separate line?

each number must be printed on a new line.

Do the numbers need to be in a specific order, or do they just need to all exist?

Are leading zeroes allowed?

@VarunPatro, please update the challenge to explicitly state that each number by on a separate line (although I'd recommend against that requirement) and make sure to inform any existing solutions that don't do so.

https://stackoverflow.com/questions/9202467/generating-all-the-increasing-digit-numbers

The md5sum of the (correct) output is 37fd279401e9ba57c8ed54e7eacb49d2.

Python 2, 56 bytes
for n in range(9999):
 if eval('<'.join(`n`))**n:print n

Try it online!
Converts each number like 124 to an expression 1<2<4 and evaluates it to check if the digits are sorted,
A hiccup happens for one-digit numbers giving an expression that just is the number itself. This causes 0 to evaluate to a Falsey value even though it should be printed. This is fixed by a trick suggested by Erik the Outgolfer of doing **n, which gives truthy value 0**0 for n=0 and doesn't affect the truth value otherwise.

What does the \`` do in `n``?

@BruceWayne It takes the string representation. This was removed in Python 3.

@BruceWayne Note that it's the same as the repr() function, not the str() function. They aren't always the same. Here's an example.

@mbomb007 thanks for that comment! I would have thought it was str() equivalent.

https://docs.python.org/2/library/functions.html#func-repr

We can handle the 0 case with a bit of trickery.

For OP: Oh, and don't use eval in real code, just in code golf.

Python 2, 55 bytes
i=0
exec"print i\ni+=1\nif eval('<'.join(`i`)):1;"*7000

Try it online!

Haskell, 50 bytes
unlines[s|s<-show<$>[0..6^5],s==scanl1(max.succ)s]

Try it online!
Outputs a multiline string. We check that the number s increasing using s==scanl1(max.succ)s, a variant of the usual sortedness check s==scanl1 max s that ensures strict sortedness by incrementing each digit character before taking the maximum of it and the next digit.
Ourous saved a byte by using 6^5 as the upper bound in place of a 4-digit number.

Jelly, 7 bytes
9ŒPḌḣ⁹Y

Try it online!
How it works
9ŒPḌḣ⁹Y  Main link. No arguments.

9        Set the return value to 9.
 ŒP      Powerset; promote 9 to [1, ..., 9] and generate all subsets.
   Ḍ     Undecimal; map the subsets of digits to the integers they represent.
     ⁹   Yield 256.
    ḣ    Dyadic head; take the first 256 elements of the integer list.
      Y  Separate the result by linefeeds.

I'm trying to figure out how 0 gets included here but I don't know Jelly. Am I correct that Jelly's powerset includes the empty array which then gets converted to 0 when "undecimaled"?

Yes, that's exactly what happens.

Japt -R, 12 11 8 bytes
L²Ç¶ìüÃð

Test it
L            :100
 ²           :Squared
  Ç          :Map the range [0,L²)
    ì        :  Split to a digit array
     ü       :  For the sake of simplicity*, let's say: Sort & deduplicate
             :  Implicitly rejoin to an integer
   ¶         :  Test for equality with original number
      Ã      :End map
       ð     :Get 0-based indices of truthy elements
             :Implicitly join with newlines and output

*Or, to offer a better explanation: the ü method sorts an array and splits it into equal elements (e.g., [8,4,8,4].ü() -> [[4,4],[8,8]]) and then, in what seems to be a strange quirk and hopefully not a bug, the ì method, when converting the array back to a number, takes the first element of each nested array, rather than first flattening the array, which is what I expected when I tried this trick (e.g., [[4,4],[8,8]].ì() -> 48).

Nice. Similar to what I had: L²Ç¥ì ü ¬Ãð

I have to say, that ü trick you guys used is genius :-) @Oliver

@Oliver, you must have posted that as I was updating; great minds ... :)

@ETHproductions, like most things, I tried it on a whim - amazed it works.

Perl 6, 25 bytes
[<](.comb)&&.say for ^1e4

-1 byte thanks to nwellnhof
Try it online!
.comb produces a list of the digits of each number, and [<] does a less-than reduction on that list, equivalent to: digit1 < digit2 < ... < digitN.

[<](.comb)&&.say saves a byte.

This is surprisingly readable.  (I already know a little Perl 6, but still...)

R, 62 49 bytes
`[`=write;0[1];for(i in 1:4)combn(1:9,i)[1,i,,""]

Try it online!
Because combn iterates through its input in the order given, it's easy to create all the lexicographically increasing integers, printing them out in order. write prints them each i-digit number in lines of width i, neatly fulfilling the newline requirement as well.

great idea exploiting combn !

Extremely clever aliasing!

Haskell, 56 55 bytes
Edit: -1 byte thanks to @Ourous
mapM print$filter(and.(zipWith(<)<*>tail).show)[0..6^5]

Try it online!

PowerShell, 42 40 bytes
0..1e4|?{-join("$_"|% t*y|sort -u)-eq$_}

Try it online!
Loop from 0 to 1e4 (i.e., 10000). Pull out those objects where |?{...} the number as a string $_ is -equal to the number cast toCharArray and then sorted with the -unique flag. In other words, only numbers that are the same as their sorted and deduplicated strings. Each of those are left on the pipeline and output is implicit.

Pyth, 10 bytes
jiRThc2yS9

Try it online!
How it works
jiRThc2yS9
        S9  Yield [1, 2, 3, 4, 5, 6, 7, 8, 9].
       y    Take all 512 subsets.
     c2     Split the array of subsets into 2 pieces (256 subsets each).
    h       Head; take the first piece.
 iRT        Convert each subset from base 10 to integer.
j           Separate by newlines.

Common Lisp, 74 72 bytes
(dotimes(i 7e3)(format(apply'char<(coerce(format()"~d"i)'list))"~d~%"i))

Try it online!
-2 bytes thank to @Shaggy!

J, 26 bytes
,.(#~(-:/:~@~.)@":"0)i.1e4

Try it online!
explanation
,. (#~ (-: /:~@~.)@":"0) i.1e4
                         i.1e4  NB. list 0 to 9999
                     "0         NB. for each number in the input list
                  @":"0         NB. convert it to a string and
   (#~ (         )              NB. remove any not passing this test:
        -:                      NB. the string of digits matches
              @~.               NB. the nub of the digits (dups removed)
           /:~                  NB. sorted
,.                              NB. ravel items: take the result of all that
                                NB. and turn it into a big column

Perl 5, 47 bytes
map{$_&&s/.(?=(.))/$1-$&/gre=~/0|-/||say}0..1E4

Try it online!
Older:
52 bytes

05AB1E (legacy), 8 bytes
4°ÝD€êÃ»

Try it online!
Works in the new version of 05AB1E as well but is painfully slow for some reason.
How?

4°ÝD€êÃ» – Full program.
4°Ý      – Push [0 ... 10000].
   D€ê   – Push each integer in [0 ... 10000] sorted and deduplicated at the same time.
      Ã» – And join the interection of the two lists by newlines.

Nice answer. Better than the 9 byter I had (which only works in the legacy).

Regenerate -a, 36 34 bytes
0|(([2-9])$4{$1/$2}|$3![1-9]()){4}

Attempt This Online!
This was directly inspired by the language's creator's answer, but I figured this big optimization building on that idea was worth its own post.
    0              # Zero must be matched as a special case, because no other
                   # numbers have a leading '0' digit.
|
    (
        ([2-9])    # \2 = a digit intended to be greater than the previous
                   #      one ($1), but until being validated below, it can
                   #      be any digit in [2-9].
                   # We could actually do ([0-9]) here and it'd generate the
                   # same output, but would run slightly less efficiently.
        $4{$1/$2}  # Repeat a nonexistent group $1/$2 number of times. $1 and $2
                   # are the literal contents of those captures interpreted as
                   # numeric values upon which arithmetic can be done in a
                   # quantifier, which we do here. $1/$2 will evaluate to
                   # zero iff $2 is greater than $1, which is the only thing
                   # that will allow it to match, because if it repeats more
                   # than zero times, it tries to match the nonexistent group
                   # $4 which can't match.
    |
        $3         # If the above fails to match, due to $1 containing the
                   # digit '9', the regex engine will try other matches, even
                   # if they use short-circuiting alternation. So we put a
                   # dummy match here, which can only match on iterations
                   # other than the first one. Once this matches, it will be
                   # the only thing that can match in all subsequent
                   # iterations, because the attempted math "$2-$1-1" will
                   # fail still - now due to $1 no longer being a number (it
                   # will be blank).
    # Short-circuiting alternation - never try the following unless the all of
    # the above failed to match.
    !
        [1-9]      # Match the first digit. This can only happen on the first
                   # iteration, thanks to the short-circuiting alternation.
        ()         # $3 = empty capture - lets subsequent iterations know that
                   #      they are no longer the first iteration
    )              # $1 = whatever digit was matched above, for use by the next
                   #      iteration
    {4}            # Repeat the above loop for exactly 4 iterations. This
                   # allows a variable number of digits, due to the "$3" dummy
                   # alternative.

Alternative 34 bytes:
0|(([2-9])$3{$1/$2}|{#1}![1-9]){4}

Attempt This Online!
It might not be intended that this is possible, but Regenerate allows a quantifier to be preceded by nothing. This is what's happening with {#1} - it's impossible for it to match on the first iteration because $1 hasn't been captured yet and doesn't have a length. On subsequent iterations, a match of nothing gets repeated one time (the length of $1).

Oh wow, nice work. The "repeat nothing" idiom was originally unintentional, I think, but once I discovered it was useful, I decided it was a feature rather than a bug. :)

Python 2, 64 61 bytes
lambda:[x for x in range(9999)if sorted(set(`x`))==list(`x`)]

Try it online!
Gets the unique characters of the integer's string representation, sorts them, and compares the result to the original number.

You can save a byte by using range(9999) or any other number between 6790 and 9999. Our solutions are almost identical BTW :)

@DJMcMayhem But then it wouldn't check ALL numbers under 10,000....:P Thanks! Sometimes I get too literal with these challenges.

Wolfram Language (Mathematica), 36 bytes
After I wrote this, it was clarified that each number must be on a new line, so +7 bytes for the Print/@.
This method takes advantage of the fact that the Subsets function 1) doesn't replicate any digits and 2) sorts the output by set size and set contents. FromDigits assembles each list of digits.
-1 byte thanks to @Mr.Xcoder
Print/@FromDigits/@Range@9~Subsets~4

Try it online!

Print/@FromDigits/@Range@9~Subsets~4 for 36 bytes.

Funny, I thought of that and just didn't do it because I thought ~ had higher precedence than @

Python 2, 61 bytes
for i in range(9999):
 if list(`i`)==sorted(set(`i`)):print i

Try it online!

V, 41 bytes
7000ïÎaÛ
Îy$úúP
Ç^¨ä*©±$/d
ÎãlD
çˆ±/d
HO0

Try it online!
Hexdump:
00000000: 3730 3030 efce 61db 0ace 7924 fafa 500a  7000..a...y$..P.
00000010: c75e a8e4 2aa9 b124 2f64 0ace e36c 440a  .^..*..$/d...lD.
00000020: e788 b12f 640a 484f 30                   .../d.HO0

Charcoal, 19 bytes
ΦＥＸχ⁴Ｉι¬Φι∧μ¬‹§ι⊖μλ

Try it online! Link is to verbose version of code. Explanation:
   χ                Predefined variable 10
  Ｘ                 To the power
    ⁴               Literal 4
 Ｅ                  Map over implicit range
      ι             Current value
     Ｉ              Cast to string
Φ                   Filter over strings where
         ι          Current string
        Φ           Filtered over characters
           μ        Character index (is nonzero)
          ∧         And
                 μ  Character index
                ⊖   Decremented
              §     Indexed into
               ι    Current string
            ¬       Is not
             ‹      Less than
                  λ Current character
       ¬            Results in an empty string
                    Implicitly print matches on separate lines

JavaScript REPL, 64 bytes
A bit of pub golf so probably far from optimal.
(f=n=>n&&f(n-1)+([...n+``].every(x=>y<(y=x),y=0)?`
`+n:``))(7e3)

Try it online
Yes, doing it without an IIFE would be a few bytes shorter but that throws an overflow error when called, which would normally be fine as we can assume infinite memory for the purposes of code golf but, to me, doesn't seem to be in the spirit of KC challenges.

I don't get an overflow error without an IIFE.

Is this a function submission or a full program? If not, you should either count the console.log or relabel your submission as JavaScript REPL.

K (ngn/k) / K (oK), 32 30 26 bytes
Solution:
`0:$&&/'1_'>':'" ",'$!9999

Try it online!
Explanation:
`0:$&&/'1_'>':'" ",'$!9999 / the solution
                     !9999 / range 0..9998 (could use !6890)
                    $      / string
               " ",'       / prepend " " to each (lower than "0" in ascii)
            >:'            / greater-than each-previous?
         1_'               / drop first result from each
      &/'                  / max (&) over (/)
    &                      / indices where true
   $                       / convert to string
`0:                        / print to stdout

C# (Visual C# Interactive Compiler), 102 101 73 ... 72 bytes
-12 and -4 thanks @Dennis!
for(var i=0;i<7e3;i++)if((i+"").Aggregate((a,b)=>a<b?b:':')<58)Print(i);

Try it online!
Each integer from 0 to 7k tested by first converting it into a string. Leveraging the fact that C# treats strings as character enumerables and LINQ, an aggregate is calculated for each character enumerable as follows:

compare the accumulated value with the current character
if the current character is greater than the accumulation, return the current character
otherwise return : which is greater than 9

If the result of this is less than : (ASCII 58), then the number has lexicographically increasing digits.

Doesn't the challenge state that all numbers from 0-10000 must be printed? I'm pretty sure this prints numbers 0-7000

I believe the largest valid number is 6789? This is less than 7000, so you don't have to go any higher.

Oh, I see. Foolish me

Not foolish at all :) I'm pretty sure I borrowed it from someone else's answer and I was scratching my head as to why they did it.

C (gcc), 97 89 81 bytes
Thanks to ceilingcat for -8 bytes.
Another -8 thanks to Dennis
g(n){n=!n||n/10%10<n%10&&g(n/10);}f(i){for(i=-1;++i<7e3;g(i)&&printf("%u\n",i));}

Try it online!

81 bytes

not gonna update this?

@ASCII-only Done. Sorry if this oversight upset you.

80 bytes

Jelly, 13 9 8 bytes
Saved 5 bytes thanks to @Dennis
9œcⱮ4ẎŻY

Try it online!
Explanation
Generates all lexicographically increasing numbers below 10000 by taking the digits [1...9] and finding all combinations of length ≤ 4.
9œcⱮ4ẎŻY    Main link. Arguments: none
9           Yield 9.
   Ɱ4       For each n in [1...4]:
 œc           Yield the combinations of the range [1...9] of length n.
     Ẏ      Tighten; dump each of the 4 lists generated into the main list.
      Ż     Prepend a 0 to the list.
       Y    Join on newlines.

Jelly, 11 10 9 bytes
Saved a byte thanks to @EriktheOutgolfer
ȷ4Ḷ<ƝẠ$ƇY

Try it online!
Explanation
Filters through the range, keeping the numbers that are lexicographically increasing.
ȷ4Ḷ<ƝẠ$ƇY    Main link. Arguments: none
ȷ4           Yield 10^4 (10000).
  Ḷ          Generate the range [0...10000).
       Ƈ     Filter; yield only the numbers where this link return a truthy value.
      $        Run these two links and yield the result.
    Ɲ            For each pair of items (digits) in the number:
   <               Check whether the left digit is less than the right digit.
     Ạ           All; check that every comparison yielded true.
               This yields whether the digits are strictly increasing.
        Y    Join the filtered list on newlines.

Regenerate -a, 72 bytes
0|([1-9])(([2-9])(){$3-$1-1}(([3-9])(){$6-$3-1}(([4-9])(){$9-$6-1})?)?)?

Appropriately, outputs the numbers in lexicographic order. Attempt This Online!
Explanation
0|

Match 0, or:
([1-9])

Match a digit 1 through 9 (capture group 1).
(...)?

Either stop there, or continue:
([2-9])

Match a digit 2 through 9 (capture group 3), and:
(){$3-$1-1}

Match an empty group X times, where X equals the second digit minus the first digit minus 1. If the second digit is not larger than the first digit, this quantity is negative, and using a negative number as a repetition count causes the match to fail. Thus, only matches where the second digit is larger than the first digit are included.
(...)?

Either stop there, or continue:
([3-9])

Match a digit 3 through 9 (capture group 6), and:
(){$6-$3-1}

Match an empty group Y times, where Y equals the third digit minus the second digit minus 1 (ensuring that the third digit is larger than the second digit).
(...)?

Either stop there, or continue:
([4-9])

Match a digit 4 through 9 (capture group 9), and:
(){$9-$6-1}

Match an empty group Z times, where Z equals the fourth digit minus the third digit minus 1 (ensuring that the fourth digit is larger than the third digit).

Very clever. But -36 bytes!

Python 2, 63 bytes
for i in range(6790):
 if`i`=="".join(sorted(set(`i`))):print i

Try it online!

T-SQL, 188 185 bytes
WITH a AS(SELECT 0n UNION ALL SELECT n+1FROM a WHERE n<9)
SELECT CONCAT(a.n,b.n,c.n,d.n)+0
FROM a,a b,a c,a d
WHERE(a.n<b.n OR a.n+b.n=0)
AND(b.n<c.n OR b.n+c.n=0)
AND(c.n<d.n OR c.n+d.n=0)

Line breaks are for readability only.
I'm certain there must be more efficient ways to do this in SQL, but this was the first thing I thought of. Explanation:

Declare an in-memory table with values 0 to 9
Cross-join 4 copies of this table for all possible values from 0000 to 9999
Messy WHERE clause to ensure the digits are strictly increasing (or both 0)
Smash the digits together (CONCAT) and convert to integer (+0)
The resulting rows may or may not be sorted, but the challenge doesn't appear to require that.

You can convert to number by adding zero x+0 instead of abs(x).

Thanks, @DrYWit, saved 3 bytes. Looks like x*1 works as well.

Stax, 8 bytes
¬ ▬A♥¶N∙

Run and debug it

MATLAB, 52 bytes
arrayfun(@(n)disp(n(all(diff(num2str(n))>0))),0:1e4)

Clean, 90 bytes
import StdEnv
Start=(0,[('
',n)\\n<-[1..6^5]|(\l=removeDup l==sort l)[c\\c<-:toString n]])

Try it online!

Red, 59 bytes
repeat n 9999[if(d: n - 1)= do sort unique form d[print d]]

Try it online!

Jelly, 7 bytes
<ƝẠ$⁹#Y

Try it online!
How?
<ƝẠ$⁹#Y - Main Link: no arguments (implicit z=0)
    ⁹   - literal 256
     #  - count up from n=z (0) finding the first 256 for which this is truthy:
   $    -   last two links as a monad:
 Ɲ      -     neighbours (implicitly gets digits of n):
<       -       less than?
  Ạ     -     all truthy? (N.B. yields 1 for an empty list)
      Y - join with newlines

Ruby, 39 bytes
puts (?0..?9*4).grep /^#{[*0..9]*??}?$/

Try it online!

JavaScript, 83 bytes
Borrowed some ideas from @Shaggy, but without recursion.
[...Array(1e4)].reduce((s,_,n)=>s+=([...n+''].every(x=>y<(y=x),y=0))?'\n'+n:'','0')

Try it online!

MathGolf, 10 bytes
♫rgÆ▒_s▀=n

Try it online!
Explanation
♫            push 10000
 r           range(0, n)
  g          pop a, (b), pop operator from code, filter
   Æ         start block of length 5
    ▒        split to list of chars/digits
     _       duplicate TOS
      s      sort(array)
       ▀     unique elements of string/list
        =    pop(a, b), push(a==b)
         n   newline char, or map array with newlines

Brachylog, 12 bytes
7jj⟦{ẹ<₁cẉ}ˢ

Try it online!
         ẉ      Write on its own line
    {     }ˢ    every
        c       concatenated
      <₁        strictly increasing
     ẹ          list of digits of
   ⟦            numbers from the range from 0 to
7jj             7777.

7jj⟦{ṫ⊆Ị&ẉ}ˢ also works.

Vyxal jM, 5 bytes
k2'Þ⇧

Try it Online!
Flagless:
Vyxal, 7 bytes
k2ʀ~Þ⇧⁋

Try it Online!

Julia, 44 bytes
0:6^5 .|>x->issorted("$x",lt=<=)&&println(x)
\$(6^5 = 7776)\$
Attempt This Online!

Retina 0.8.2, 38 bytes

9999$*
.
$.`¶
.
$*_$&
A`(_*)\d\1\d
_

Try it online! Explanation:

9999$*

Insert 9999 characters.
.
$.`¶

Convert into a list of numbers 0..9998
.
$*_$&

Prefix each digit with its value in _s.
A`(_*)\d\1\d

Delete lines containing nonincreasing digits.
_

Remove the now unnecessary _s.

Pyth, 15 bytes
jf.A<V`Tt`TU^T4

Try it here!

Bash + GNU Core Utilities, 57 bytes
seq 1e4|grep -vP `seq 0 9|sed 's/./(&[0-&])/'|tr '
' \|`p

Uses some meta-regex-generation shit

Your output is missing the 0.

47 bytes

K4, 19 bytes
Solution:
-1@$&&/'>':'$!9999;

Explanation:
-1@$&&/'>':'$!9999; / the solution
             !9999  / range 0..9998
            $       / string
        >':'        / greater-than (>) each-previous (':) each (')
     &/'            / max (&) over (/)
    &               / indices where true
   $                / string
  @                 / apply
-1                ; / print to stdout and swallow return value (-1)

Kotlin, 132 131 bytes
Edit: -1 Byte thanks to @Giuseppe
fun main(){(0..9999).forEach{it.toString().let{var b=1;it.forEachIndexed{i,c->if(i>0&&it[i-1]<c)b++};if(b==it.length)println(it)}}}

Try it online!

I don't know Kotlin, but a trivial golf is replacing 10000 with 9999

alternative 131

96

95

Tcl, 116 bytes
set i 0
time {set m -1;lmap n [split $i ""] {if $n>$m {set m $n} {set m X;break}}
if \$m!="X" {puts $i}
incr i} 9999

Try it online!

Oracle SQL, 163 bytes
Various ways to generate combinations
with a(n)as(select level-1 from dual connect by level<11),r(i,x,s)as(select 1,n,n||''from a union all select i+1,n,s||n from r,a where(x<n or n+x=0)and i<4)select s+0 from r where i=4;

with a(n)as(select level-1 from dual connect by level<11)select a.n||b.n||c.n||d.n+0 from a,a b,a c,a d where(a.n<b.n or a.n+b.n=0)and(b.n<c.n or b.n+c.n=0)and(c.n<d.n or c.n+d.n=0);

with a(n)as(select level from dual connect by level<11)select unique replace(sys_connect_by_path(n-1,'#'),'#')+0 from(a)connect by level<5and prior n<n order by 1;

Rec with (CTE), 184 bytes
Self joins, 182 bytes
Connect by, 163 bytes

Just for fun
with t(c)as(select ku$_vcnt(1,2,3,4,5,6,7,8,9) from dual)
select listagg(value(z)) within group (order by 0) + 0 n
  from (select rownum r, value(r) v
          from t, table(powermultiset(c)) r),
       table(v) z
 where cardinality(v) < 5
group by r union select 0 from dual

.
with a(n)as(select decode(level,10,null,level) from dual connect by level<11)
select nvl(a.n || b.n || c.n || d.n + 0, 0) n
  from a, a b, a c, a d
 where nvl2(b.n, sign(b.n - a.n), 1) = 1
   and nvl2(c.n, sign(c.n - b.n), 1) = 1
   and nvl2(d.n, sign(d.n - c.n), 1) = 1
 order by 1

PHP, 51 bytes
while($n<1e4)count_chars($n,3)-$n++||print~-$n."
";

Run with -nr or try it online.

count_chars($string,$mode=3) returns a string of all used characters in ascending order.
This equals the input if, and only if, its characters (in this case: digits) are strictly increasing.
$n is NULL in the first iteration; count_chars returns an empty string; NULL-"" is evaluated as 0-0.

APL (Dyalog Extended), 28 bytes
{(⍵≡∪⍵)∧⍵≡∧⍵:⎕←⍵⋄⍬}∘⍕¨⍳10000

Try it online!
Explanation:
{(⍵≡∪⍵)∧⍵≡∧⍵:⎕←⍵⋄⍬}∘⍕¨⍳10000 ⍝ Full program
                          ⍳10000 ⍝ Generate integers from 1 to 10000
                      ∘⍕¨       ⍝ For each number, convert to string and apply left function
         ⍵≡∧⍵                   ⍝ If the string equals itself sorted...
 (⍵≡∪⍵)∧                        ⍝ ...and the string contains only unique elements...
               ⎕←⍵              ⍝ ...print the string to output with trailing newline
                   ⋄⍬            ⍝ Otherwise, do nothing

↑c/⍨(,⍨≡∧,∪)¨c←⍕¨⍳1E4

C++ (gcc), 113 bytes
bool y(int a){return(a==0||a%10>(a/=10)%10&&y(a))?true:false;}void z(int i){while(++i<7e3)if(y(i))cout<<i<<endl;}

Try it online!
Pretty Layout:
#include<iostream>
using namespace std;

bool y(int a){
    return(a==0||a%10>(a/=10)%10&&y(a))?true:false;
}

void z(int i){
    while(++i<7e3){
        !y(i)?:cout<<i<<endl;
    }
}

int main(){
    z(-1);
}

97 bytes

Java 8
Full program: 186 bytes
interface M{static void main(String[]a){for(int i=-1;i++<9999;System.out.print((i+"").chars().distinct().sorted().mapToObj(c->(c-48)+"").reduce("",(x,y)->x+y).equals(i+"")?i+"\n":""));}}

Function: 149 bytes
v->{for(int i=-1;i++<9999;System.out.print((i+"").chars().distinct().sorted().mapToObj(c->(c-48)+"").reduce("",(x,y)->x+y).equals(i+"")?i+"\n":""));}

Burlesque, 11 bytes
1e4qsoFO:U_

Equivalently
1e4ro:so:U_

Try it online!
1e4 # 10000
qso # Boxed is sorted?
FO  # Filter from 1..10000 if sorted
:U_ # Filter for unique digits


text:
Dirichlet Convolution
The Dirichlet convolution is a special kind of convolution that appears as a very useful tool in number theory. It operates on the set of arithmetic functions.
Challenge
Given two arithmetic functions \$f,g\$ (i.e. functions \$f,g: \mathbb N \to \mathbb R\$) compute the Dirichlet convolution \$(f * g): \mathbb N \to \mathbb R\$ as defined below.
Details

We use the convention \$ 0 \notin \mathbb N = \{1,2,3,\ldots \}\$.
The Dirichlet convolution \$f*g\$  of two arithmetic functions \$f,g\$ is again an arithmetic function, and it is defined as $$(f * g)(n) = \sum_\limits{d|n} f\left(\frac{n}{d}\right)\cdot g(d) = \sum_{i\cdot j = n} f(i)\cdot g(j).$$ (Both sums are equivalent. The expression \$d|n\$ means \$d \in \mathbb N\$ divides \$n\$, therefore the summation is over the natural divisors of  \$n\$. Similarly we can subsitute \$ i = \frac{n}{d} \in \mathbb N, j =d \in \mathbb N \$ and we get the second equivalent formulation. If you're not used to this notation there is a step by step example at below.) Just to elaborate (this is not directly relevant for this challenge): The definition comes from computing the product of Dirichlet series: $$\left(\sum_{n\in\mathbb N}\frac{f(n)}{n^s}\right)\cdot \left(\sum_{n\in\mathbb N}\frac{g(n)}{n^s}\right) = \sum_{n\in\mathbb N}\frac{(f * g)(n)}{n^s}$$
The input is given as two black box functions. Alternatively, you could also use an infinite list, a generator, a stream or something similar that could produce an unlimited number of values.
There are two output methods: Either a function \$f*g\$ is returned, or alternatively you can take take an additional input \$n \in \mathbb N\$ and return \$(f*g)(n)\$ directly.
For simplicity you can assume that every element of \$ \mathbb N\$ can be represented with e.g. a positive 32-bit int.
For simplicity you can also assume that every entry \$ \mathbb R \$ can be represented by e.g. a single real floating point number.

Examples
Let us first define a few functions. Note that the list of numbers below each definition represents the first few values of that function.

the multiplicative identity (A000007)
$$\epsilon(n) = \begin{cases}1 & n=1 \\ 0 & n>1 \end{cases}$$
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...
the constant unit function (A000012)$$ \mathbb 1(n) = 1 \: \forall n $$
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...
the identity function (A000027)
$$ id(n) = n \: \forall n $$
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, ...
the Möbius function (A008683)
$$ \mu(n) = \begin{cases} (-1)^k & \text{ if } n \text{ is squarefree and } k \text{ is the number of Primefactors of } n \\ 0 & \text{ otherwise } \end{cases} $$
1, -1, -1, 0, -1, 1, -1, 0, 0, 1, -1, 0, -1, 1, 1, 0, -1, 0, -1, ...
the Euler totient function (A000010)
$$ \varphi(n) = n\prod_{p|n} \left( 1 - \frac{1}{p}\right) $$
1, 1, 2, 2, 4, 2, 6, 4, 6, 4, 10, 4, 12, 6, 8, 8, 16, 6, 18, 8, ...

the Liouville function (A008836)
$$ \lambda (n) = (-1)^k $$ where \$k\$ is the number of prime factors of \$n\$ counted with multiplicity
1, -1, -1, 1, -1, 1, -1, -1, 1, 1, -1, -1, -1, 1, 1, 1, -1, -1, -1, ...
the divisor sum function (A000203)
$$\sigma(n) = \sum_{d | n} d $$
1, 3, 4, 7, 6, 12, 8, 15, 13, 18, 12, 28, 14, 24, 24, 31, 18, 39, 20, ...
the divisor counting function (A000005)
$$\tau(n) = \sum_{d | n} 1 $$
1, 2, 2, 3, 2, 4, 2, 4, 3, 4, 2, 6, 2, 4, 4, 5, 2, 6, 2, 6, 4, 4, 2, 8, ...
the characteristic function of square numbers (A010052)
$$sq(n) = \begin{cases} 1 & \text{ if } n \text{ is a square number} \\ 0 & \text{otherwise}\end{cases}$$
1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, ...

Then we have following examples:

\$ \epsilon = \mathbb 1 * \mu \$
\$ f = \epsilon * f \: \forall f \$
\$  \epsilon = \lambda * \vert \mu \vert \$
\$ \sigma = \varphi * \tau \$
\$ id = \sigma * \mu\$ and \$ \sigma = id * \mathbb 1\$
\$ sq = \lambda * \mathbb 1 \$ and \$ \lambda = \mu * sq\$
\$ \tau = \mathbb 1 * \mathbb 1\$ and \$ \mathbb 1 = \tau * \mu \$
\$ id = \varphi * \mathbb 1 \$ and \$ \varphi = id * \mu \$

The last for are a consequence of the Möbius inversion: For any \$f,g\$ the equation \$ g = f * 1\$ is equivalent to \$f = g * \mu \$.
Step by Step Example
This is an example that is computed step by step for those not familiar with the notation used in the definition. Consider the functions \$f = \mu\$ and \$g = \sigma\$. We will now evaluate their convolution \$\mu * \sigma\$ at \$ n=12\$. Their first few terms are listed in the table below.
$$\begin{array}{c|ccccccccccccc}
f & f(1) & f(2) & f(3) & f(4) & f(5) & f(6) & f(7) & f(8) & f(9) & f(10) & f(11) & f(12)
\\ \hline
\mu & 1 & -1 & -1 & 0 & -1 & 1 & -1 & 0 & 0 & 1 & -1 & 0
\\
\sigma & 1 & 3 & 4 & 7 & 6 & 12 & 8 & 15 & 13 & 18 & 12 & 28
\\
\end{array}$$
The sum iterates over all natural numbers \$ d \in \mathbb N\$ that divide \$n=12\$, thus \$d\$ assumes all the natural divisors of \$n=12 = 2^2\cdot 3\$. These are \$d =1,2,3,4,6,12\$. In each summand, we evaluate \$g= \sigma\$ at \$d\$ and multiply it with \$f = \mu\$ evaluated at \$\frac{n}{d}\$. Now we can conclude
$$\begin{array}{rlccccc}
(\mu * \sigma)(12) &= \mu(12)\sigma(1) &+\mu(6)\sigma(2) &+\mu(4)\sigma(3) &+\mu(3)\sigma(4) &+\mu(2)\sigma(6) &+\mu(1)\sigma(12)
\\
&= 0\cdot 1 &+ 1\cdot 3 &+ 0 \cdot  4 &+ (-1)\cdot 7 &+ (-1) \cdot 12 &+ 1 \cdot 28
\\
&= 0 & + 3 & 1 0 & -7 & - 12 & + 28
\\
&= 12 \\
& = id(12)
\end{array}$$

Lean, 108 100 95 78 75 bytes
def d(f g:_->int)(n):=(list.iota n).foldr(λd s,ite(n%d=0)(s+f d*g(n/d))s)0

Try it online!
More testcases with all of the functions.

is lambda really more expensive than four bytes for fun ?

lambda is three bytes, I suppose

I think it's two in UTF8 (greek is pretty low unicode)

You're right. I also golfed the import

I also used cond to save 5 bytes

ah, I was going to suggest (((list.range$n+1).filter$(∣)n).map(λd,f d*g(n/d))).sum but I think you beat that now

ite is even shorter than cond :)

and λd,f d*g(n/d)*min(n%d)1 is even shorter

I think (∣)n has the wrong order?

oh right. the other order is (∣n)

λd,f d*g(n/d)*min(n%d)1 is incorrect

and I got rid of the import by using foldr

you can use list.iota n instead of list.range$n+1 and save some characters... and also avoid 0 in the fold. Why was it even correct before, don't you get an undesirable f 0*g 0 term?

because 15%0=15

Haskell, 46 bytes
(f!g)n=sum[f i*g(div n i)|i<-[1..n],mod n i<1]

Try it online!
Thanks to flawr for -6 bytes and a great challenge! And thanks to H.PWiz for another -6!

Simpler is shorter here

@H.PWiz That's pretty clever - I didn't even think of doing it that way!

Wolfram Language (Mathematica), 17 bytes
Of course Mathematica has a built-in.  It also happens to know many of the example functions.  I've included some working examples.
DirichletConvolve

Try it online!

Python 3, 59 bytes
lambda f,g,n:sum(f(d)*g(n//d)for d in range(1,n+1)if 1>n%d)

Try it online!

Is // really needed instead of /?

/ would produce floats right?

Because d is a divisor of n by definition, the fractional part of n/d is zero, so there shouldn't be any issues with floating point arithmetic. Floats with fractional part zero are close enough to ints for Pythonic purposes, and the output of the function is a real number, so doing n/d instead of n//d should be fine.

Add++, 51 bytes
D,g,@~,$z€¦~¦*
D,f,@@@,@b[VdF#B]dbRzGb]$dbL$@*z€g¦+

Try it online!
Takes two pre-defined functions as arguments, plus \$n\$, and outputs \$(f * g)(n)\$
How it works
D,g,		; Define a helper function, $g
	@~,	; $g takes a single argument, an array, and splats that array to the stack
		; $g takes the argument e.g. [[τ(x) φ(x)] [3 4]]
		; STACK : 			[[τ(x) φ(x)] [3 4]]
	$z	; Swap and zip:			[[3 τ(x)] [4 φ(x)]]
	€¦~	; Reduce each by execution:	[[τ(3) φ(4)]]
	¦*	; Take the product and return:	τ(3)⋅φ(4) = 4

D,f,		; Define the main function, $f
	@@@,	; $f takes three arguments: φ(x), τ(x) and n (Let n = 12)
		; STACK:			[φ(x) τ(x) 12]
	@	; Reverse the stack:		[12 τ(x) φ(x)]
	b[V	; Pair and save:		[12]			Saved: [τ(x) φ(x)]
	dF#B]	; List of factors:		[[1 2 3 4 6 12]]
	dbR	; Copy and reverse:		[[1 2 3 4 6 12] [12 6 4 3 2 1]]
	z	; Zip together:			[[[1 12] [2 6] [3 4] [4 3] [6 2] [12 1]]]
	Gb]	; Push Saved:			[[[1 12] [2 6] [3 4] [4 3] [6 2] [12 1]] [[τ(x) φ(x)]]]
	$dbL	; Number of dividors:		[[[τ(x) φ(x)]] [[1 12] [2 6] [3 4] [4 3] [6 2] [12 1]] 6]
	$@*	; Repeat:			[[[1 12] [2 6] [3 4] [4 3] [6 2] [12 1]] [[τ(x) φ(x)] [τ(x) φ(x)] [τ(x) φ(x)] [τ(x) φ(x)] [τ(x) φ(x)] [τ(x) φ(x)]]]
	z	; Zip:				[[[τ(x) φ(x)] [1 12]] [[τ(x) φ(x)] [2 6]] [[τ(x) φ(x)] [3 4]] [[τ(x) φ(x)] [4 3]] [[τ(x) φ(x)] [6 2]] [[τ(x) φ(x)] [12 1]]]
	€g	; Run $g over each subarray:	[[4 4 4 6 4 6]]
	¦+	; Take the sum and return:	28

R, 58 bytes
function(n,f,g){for(i in (1:n)[!n%%1:n])F=F+f(i)*g(n/i)
F}

Try it online!
Takes n, f, and g. Luckily the numbers package has quite a few of the functions implemented already.
If vectorized versions were available, which is possible by wrapping each with Vectorize, then the following 45 byte version is possible:
R, 45 bytes
function(n,f,g,x=1:n,i=x[!n%%x])f(i)%*%g(n/i)

Try it online!

APL (Dyalog Classic), 20 bytes
{(⍺⍺¨∘⌽+.×⍵⍵¨)∪⍵∨⍳⍵}

with ⎕IO←1
Try it online!
Easy to solve, hard to test - generally not my type of challenge. Yet, I enjoyed this one very much!
{ } defines a dyadic operator whose operands ⍺⍺ and ⍵⍵ are the two functions being convolved; ⍵ is the numeric argument
∪⍵∨⍳⍵ are the divisors of ⍵ in ascending order, i.e. unique (∪) of the LCMs (∨) of ⍵ with all natural numbers up to it (⍳)
⍵⍵¨ apply the right operand to each
⍺⍺¨∘⌽ apply the left operand to each in reverse
+.× inner product - multiply corresponding elements and sum

The same in ngn/apl looks better because of Unicode identifiers, but takes 2 additional bytes because of 1-indexing.

Pretty sure it takes 27 additional bytes in ngn/apl...

Jelly, 9 bytes
ÆDṚÇ€ḋÑ€Ʋ

Try it online!
Line at the top is the main line of \$f\$, line at the bottom is the main line of \$g\$. \$n\$ is passed as an argument to this function.

Swift 4,  74 70  54 bytes
{n in(1...n).map{n%$0<1 ?f(n/$0)*g($0):0}.reduce(0,+)}

Try it online!

JavaScript (ES6), 47 bytes
Takes input as (f)(g)(n).
f=>g=>h=(n,d=n)=>d&&!(n%d)*f(n/d)*g(d)+h(n,d-1)

Try it online!
Examples
liouville =
n => (-1) ** (D = (n, k = 2) => k > n ? 0 : (n % k ? D(n, k + 1) : 1 + D(n / k, k)))(n)

mobius =
n => (M = (n, k = 1) => n % ++k ? k > n || M(n, k) : n / k % k && -M(n / k, k))(n)

sq =
n => +!((n ** 0.5) % 1)

identity =
n => 1

// sq = liouville * identity
console.log([...Array(25)].map((_, n) => F(liouville)(identity)(n + 1)))

// liouville = mobius * sq
console.log([...Array(20)].map((_, n) => F(mobius)(sq)(n + 1)))

C (gcc), 108 bytes
#define F float
F c(F(*f)(int),F(*g)(int),int n){F s=0;for(int d=0;d++<n;)if(n%d<1)s+=f(n/d)*g(d);return s;}

Straightforward implementation, shamelessly stolen from Leaky Nun's Python answer.
Ungolfed:
float c(float (*f)(int), float (*g)(int), int n) {
    float s = 0;
    for(int d = 1; d <= n;++d) {
        if(n % d == 0) {
            s += f(n / d) * g(d);
        }
    }
    return s;
}

Try it online!

95

F#, 72 bytes
let x f g n=Seq.filter(fun d->n%d=0){1..n}|>Seq.sumBy(fun d->f(n/d)*g d)

Takes the two functions f and g and a natural number n. Filters out the values of d that do not naturally divide into n. Then evaluates f(n/d)  and g(d), multiples them together, and sums the results.

Pari/GP, 32 bytes
(f,g,n)->sumdiv(n,d,f(n/d)*g(d))

Try it online!
There is a built-in dirmul function, but it only supports finite sequences.

APL(NARS), 47 chars, 94 bytes
{(m⍵[1])×n⍵[2]}{+/⍺⍺¨{k←⍳⍵⋄(⍵÷b),¨b←k/⍨0=k∣⍵}⍵}

where m and n are the function one has to use (this because i don't know how
to call one array of function in one function in APL).
Using the example above the multiplication of Mobius function (here it is 12π) and sum of divisors
function (here it is 11π) for value 12 that multiplication would be:
  {(12π⍵[1])×11π⍵[2]}{+/⍺⍺¨{k←⍳⍵⋄(⍵÷b),¨b←k/⍨0=k∣⍵}⍵}12
12

if one has to calculate some other value:
  {(12π⍵[1])×11π⍵[2]}{+/⍺⍺¨{k←⍳⍵⋄(⍵÷b),¨b←k/⍨0=k∣⍵}⍵}1002
1002
  {(12π⍵[1])×11π⍵[2]}{+/⍺⍺¨{k←⍳⍵⋄(⍵÷b),¨b←k/⍨0=k∣⍵}⍵}1001
1001
  {(12π⍵[1])×11π⍵[2]}{+/⍺⍺¨{k←⍳⍵⋄(⍵÷b),¨b←k/⍨0=k∣⍵}⍵}20000x
20000

One can see if for example the first 2000 number the function result is the identity
  (⍳2000)≡{(12π⍵[1])×11π⍵[2]}{+/⍺⍺¨{k←⍳⍵⋄(⍵÷b),¨b←k/⍨0=k∣⍵}⍵}¨⍳2000
1

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Kolmogorov Flexibility. A.K.A. Sale! \$38\%\$ Off All Codegolf While Stocks Last!
This is a restricted-source, kolmogorov-complexity, code-golf challenge to produce a fixed output with no input.
The output format, however, is flexible - it may be printed to standard out, printed to standard error, returned as a list of characters, returned as a list of bytes, or returned as a list of integers. If you think anything else seems reasonable just ask in the comments!
Here is a simple, big-letter ASCII art CODEGOLF:
 CCCC   OOO   DDDD   EEEEE   GGG    OOO   L      FFFFF
C      O   O  D   D  E      G      O   O  L      F
C      O   O  D   D  EEE    G  GG  O   O  L      FFF
C      O   O  D   D  E      G   G  O   O  L      F
 CCCC   OOO   DDDD   EEEEE   GGGG   OOO   LLLLL  F

Without any newlines (or trailing spaces on any lines) it is 256 characters long:
 CCCC   OOO   DDDD   EEEEE   GGG    OOO   L      FFFFFC      O   O  D   D  E      G      O   O  L      FC      O   O  D   D  EEE    G  GG  O   O  L      FFFC      O   O  D   D  E      G   G  O   O  L      F CCCC   OOO   DDDD   EEEEE   GGGG   OOO   LLLLL  F

The (0-based) indices of the non-space characters are:
1, 2, 3, 4, 8, 9, 10, 14, 15, 16, 17, 21, 22, 23, 24, 25, 29, 30, 31, 36, 37, 38, 42, 49, 50, 51, 52, 53, 54, 61, 65, 68, 72, 75, 82, 89, 93, 96, 103, 104, 111, 115, 118, 122, 125, 126, 127, 132, 135, 136, 139, 143, 146, 153, 154, 155, 156, 163, 167, 170, 174, 177, 184, 188, 191, 195, 198, 205, 207, 208, 209, 210, 214, 215, 216, 220, 221, 222, 223, 227, 228, 229, 230, 231, 235, 236, 237, 238, 242, 243, 244, 248, 249, 250, 251, 252, 255

You may not use any of these 97 bytes in your code but must produce a list (or similarly output) these bytes, in this order, with the missing bytes replaced by the 32nd byte in the code page you are using (in many, many code-pages a space character).
You may include the pretty-printing* newlines (but no trailing spaces on the lines) if it helps.
For example using the Jelly code-page this output is acceptable:
 ¢£¤¥   ®µ½   ÇÐÑ×   ßæçðı   øœþ    $%&   *      12345
6      =   A  D   H  K      R      Y   ]  `      g
h      o   s  v   z  }~¶    ⁴  ⁷⁸  ⁻   Ɓ  Ƒ      ƲȤɓ
ƈ      ɲ   ʂ  ȥ   Ẹ  Ḳ      Ṭ   Ỵ  Ḃ   Ḟ  İ      Ṡ
 ẆẊẎŻ   ẹḥị   ṇọṛṣ   ẉỵẓȧḃ   ḟġḣŀ   ṗṙṡ   ẏż«»‘  ”

...but so is:
 ¢£¤¥   ®µ½   ÇÐÑ×   ßæçðı   øœþ    $%&   *      123456      =   A  D   H  K      R      Y   ]  `      gh      o   s  v   z  }~¶    ⁴  ⁷⁸  ⁻   Ɓ  Ƒ      ƲȤɓƈ      ɲ   ʂ  ȥ   Ẹ  Ḳ      Ṭ   Ỵ  Ḃ   Ḟ  İ      Ṡ ẆẊẎŻ   ẹḥị   ṇọṛṣ   ẉỵẓȧḃ   ḟġḣŀ   ṗṙṡ   ẏż«»‘  ”

...and so is:
[32, 1, 2, 3, 4, 32, 32, 32, 8, 9, 10, 32, 32, 32, 14, 15, 16, 17, 32, 32, 32, 21, 22, 23, 24, 25, 32, 32, 32, 29, 30, 31, 32, 32, 32, 32, 36, 37, 38, 32, 32, 32, 42, 32, 32, 32, 32, 32, 32, 49, 50, 51, 52, 53, 54, 32, 32, 32, 32, 32, 32, 61, 32, 32, 32, 65, 32, 32, 68, 32, 32, 32, 72, 32, 32, 75, 32, 32, 32, 32, 32, 32, 82, 32, 32, 32, 32, 32, 32, 89, 32, 32, 32, 93, 32, 32, 96, 32, 32, 32, 32, 32, 32, 103, 104, 32, 32, 32, 32, 32, 32, 111, 32, 32, 32, 115, 32, 32, 118, 32, 32, 32, 122, 32, 32, 125, 126, 127, 32, 32, 32, 32, 132, 32, 32, 135, 136, 32, 32, 139, 32, 32, 32, 143, 32, 32, 146, 32, 32, 32, 32, 32, 32, 153, 154, 155, 156, 32, 32, 32, 32, 32, 32, 163, 32, 32, 32, 167, 32, 32, 170, 32, 32, 32, 174, 32, 32, 177, 32, 32, 32, 32, 32, 32, 184, 32, 32, 32, 188, 32, 32, 191, 32, 32, 32, 195, 32, 32, 198, 32, 32, 32, 32, 32, 32, 205, 32, 207, 208, 209, 210, 32, 32, 32, 214, 215, 216, 32, 32, 32, 220, 221, 222, 223, 32, 32, 32, 227, 228, 229, 230, 231, 32, 32, 32, 235, 236, 237, 238, 32, 32, 32, 242, 243, 244, 32, 32, 32, 248, 249, 250, 251, 252, 32, 32, 255]

(This last one is a valid list output in any language with any code-page, and one may use any reasonable list-formatting too.)

Here is Python 3 code which shows the unavailable ASCII bytes.
* Although the printing itself might not actually be all that pretty!

You may not use any of these 97 bytes in your code Does that mean I may not use these ASCII characters: $%&*123456=ADHKRY]``ghosvz}~ and no newline?

@Titus If your code-page aligns with ASCII then yes - or a tab or any of the other chars in the range given, e.g. the unprintables or extended. (Also - see the linked Python script at TIO)

For what it's worth, here is a code validator (assuming no special code-page).

I almost have it in PHP ... only need a way to array_map(function($n){return sprintf("%6b",$n);},...) without a $ (I could do that) AND without } (no idea). Yes; I want to pack the data!

Python 2, 321 203 bytes
print map(lambda(i,x):(x>'0'and i-8-8-8-8)+8+8+8+8,enumerate(bin(int(reduce(lambda x,y:x+repr('abcdefijkl'.find(y)),'cfjdbljcibkeajjejiljjlcbjddlafklebajjlceljdeadficijflealkeklkljadfbbckjebclkf','')))))

Try it online!

Explanation:
from the inside out:
cfjdbljcibkeajjejiljjlcbjddlafklebajjlceljdeadficijflealkeklkljadfbbckjebclk is the number 25731972618407747697792173390589410779249734035626759409848989703511287412985 encoded with allowed characters. (No 123456's allowed)
reduce(lambda x,y:x+repr('abcdefijkl'.find(y)),'cfjdbl..bclkf','')
maps the string to its decimal string:

reduce(lambda x,y:x+y,'..','') is the same as ''.join('..') (No o's allowed)
repr('..') instead of str('..') (No s's allowed)
'abcdefijkl'.find(y) maps a char to a digit.

enumerate(bin(int(...))) converts the number string to a binary string, and enumerates. This gives the pairs [(0,0), (1,b), (2,1), (3,1), ...]
map(lambda(i,x):(x>'0'and i-8-8-8-8)+8+8+8+8, ... ) converts the enumerated list to the final result.

map(lambda(i,x):.. , .. ) instead of [... for(i,x)in ...] (No o]'s allowed)
lambda(i,x): .. converts each (index,value) pair to either the index or 32.
(x>'0'and i-8-8-8-8)+8+8+8+8 is the same as:

x>'0'and i or 8+8+8+8, (No o's allowed)
[8+8+8+8,i][x>'0'] or [8<<9-7,i][x>'0'], (No ]'s allowed)

8+8+8+8 = 32 (No 23's allowed)

This means that the program is essentially the same as:
print[[32,i][x>'0']for i,x in enumerate(bin(25731972618407747697792173390589410779249734035626759409848989703511287412985))]

Some nice golfing work there :D

C (gcc), 318 bytes
main(_){--_<88+80+88?printf((int[:>){77707-989908070??>,((int[:>){0xE8E8C79E^0xB0B0080,0xC07E0870^0xE0000C00,0xCC08099C^0xEE0C008E,0xE8888989^0xCC00808,0x9E088990^0x800C0000,0x990C8888^0x080ECC00,0xF9C7a088^0x080000C0,0x9F8C78F8^0x900000??>[_>>(0xC^0x9):>>>(_<<9+9+9>>9+9+9))<<(70^89)>>(70^89)?_:' '),main(_+9-7):0;??>

Try it online!
This one is a bit of a journey...
1. Compressing the list
Somehow we will need to check if a given integer is one of the special code points. Any 'naked' list will be far too long, so we use a check list. This list has a non-zero value at code points that are 'restricted' and a zero value at those that aren't.
Unfortunately this still takes 512 bytes just to have the list (it looks like 0,0,7,7,0,7,0,...). This can be shortened with a bitmask.
To make use of the bitmask we will break each byte into two pieces. The first 3 bits will pick a mask from an array while the last 5 will pick a bit in the array. We can't shrink the array any further because the 32-bit integers used by default don't support any more than 2^5=32 bits.
Using a reference implementation I wrote:
int main() {
    int i;
    int vals[] = {1, 2, 3, 4, 8, 9, 10, 14, 15, 16, 17, 21, 22, 23, 24, 25, 29, 30, 31, 36, 37, 38, 42, 49, 50, 51, 52, 53, 54, 61, 65, 68, 72, 75, 82, 89, 93, 96, 103, 104, 111, 115, 118, 122, 125, 126, 127, 132, 135, 136, 139, 143, 146, 153, 154, 155, 156, 163, 167, 170, 174, 177, 184, 188, 191, 195, 198, 205, 207, 208, 209, 210, 214, 215, 216, 220, 221, 222, 223, 227, 228, 229, 230, 231, 235, 236, 237, 238, 242, 243, 244, 248, 249, 250, 251, 252, 255, 0};

    for (i = 0; i <= 0xFF; ++i) {
        int j,f;
        f = 0;
        for (j = 0; vals[j]; ++j)
            if (vals[j] == i)
                f = 1;
        if (f)
            printf("1");
        else
            printf("0");

        if (i%32 == 31)
            printf("\n");
    }

    return 0;
}

I was able to generate the appropriate values for this new array using the command echo "obase=16;ibase=2;$(./a.out | rev)" | bc. This passes the output of the above program (./a.out) to the rev program, which reverses each line. It prints this along with a header to bc that sets the output base to 16 and input base to 2. Thus bc converts the binary digits to a hexadecimal bitmask.
The resulting array is can be seen in this 'beta' solution:
f(){
    int x;
    int arr[] = {0xE3E3C71E, 0x207E0470, 0x22040912, 0xE4488181, 0x1E048990, 0x91024488, 0xF1C7A048, 0x9F1C78F8};
    for (x=0; x<=0xFF; ++x) {
        int mask = arr[x >> 5];
        int bit = mask >> (x & 0x1F);

        if (bit & 1)
            printf("%c", x);
        else
            printf(" ");
    }
}

2. Dealing with the constraints
There are a lot of constraints that need to be placed on the above code. Here I go through each of them 1-by-1.

No assignment

This is felt by other languages as well, without assignment in C it is very hard to get any guaranteed values into variables. The easiest way for us is to write our function as a full program. The first argument of main will be passed the value of argc which will be 1 if called with no arguments.

No looping

The only looping constructs in C are for, while, and goto all of which contain restricted characters. This leaves us with using recursion. The main function will start at 1 and recurse until the argument is >256, meanwhile it will decrement the argument internally to use a 0-indexed value.

Hex values

The values in the above array are hexadecimal, even when converted to decimal, these contain some restricted symbols, most notably 123456 (AD can be lower-cased). To work around this each constant is XORed with another such that the restricted characters are removed. 1 becomes 9^B, 2 becomes C^E, 3 becomes B^8, 4 becomes 8^C, 5 becomes 9^C, and 6 becomes 9^F (there are more ways to do it, I chose this way).

Printing

The restrictions don't leave many printing functions left to us. putchar and puts are both restricted, leaving printf. Unfortunately we have to send printf a format string, ideally "%c". All such strings have that pesky percent sign that we wish to remove. Luckily we assume a little-endian machine (because apparently that's what TIO uses, and that's pretty typical). By constructing the integer whose bytes in memory are 0x25 (%), 0x63 (c), 0x00 (\0), anything (doesn't matter, its after the null terminator) we can just pass its address to printf and it will assume it is a string. One such number that works is -989830363 (0xC5006325). This is easy to create under the restrictions as 77707-989908070.
There's still the issue that we can't reference any values (because we can't assign them and because we can't use &), so we have to use an array literal (int[]){...}. We actually use this for the bitmask array above as well.

Closing brackets

We can't use ']' or '}' to close either our arrays or functions. Luckily C has digraphs and trigraphs that work. :> will become ], while ??> will become }. This requires gcc to take the -trigraphs switch, as it ignores trigraphs by default (in violation of the standard).

Bitwise operations

We can't use & to mask bits off of our index, nor can we use % to get there the old-fashioned way. Therefore we rely on implementation specific behaviour. In particular we shift our 32-bit integers far enough to the left to lose bits, then back to the right. For example to get the last 5 bits of our number we first shift it left 27 bits (leaving abcde00000...) then shift it back to the right by 27 bits (leaving ...00000abcde).

Miscellaneous values

We need a few more literal values throughout the code - these are taken from Arnauld's JS answer, plus 27 (for the reason above) is added by me as 9+9+9.
3. Putting it together
Here is the description of the source with all of these changes together.
main(_){                // This is our main entry point
--_<88+80+88            // This subtracts 1 from the argument (_) and checks if it is less than 256
    ?                   // If it is less than 256 we 'continue'
printf(                 // first we call printf with...
    (int[:>){           // An integer array that will be interpreted as a string
    77707-989908070     // With the value we determined above, to represent "%c\0\xC5"
    ??>,                // This is a trigraph for }, just as the :> above is a digraph for ]
    ((int[:>){          // We immediately create another integer array
0xE8E8C79E^0xB0B0080,   // Each row is the bit-mask for 32 characters
0xC07E0870^0xE0000C00,
0xCC08099C^0xEE0C008E,
0xE8888989^0xCC00808,
0x9E088990^0x800C0000,
0x990C8888^0x080ECC00,
0xF9C7a088^0x080000C0,
0x9F8C78F8^0x900000??>
[_>>(0xC^0x9):>         // This is {arr}[_>>5] just in a roundabout way
>>(_<<9+9+9>>9+9+9))    // Similarly this is (...)>>(_&0x1F)
<<(70^89)>>(70^89)      // This is <<31>>31 or &1, to check the last bit
?_:' ')                 // If its 1, we print the character, otherwise we print a space
,main(_+9-7):0;         // We recurse, the :0 is the other branch of the if, it terminates execution
??>

Great job! Nice explanation too. (I'm not 100% but believe the header should read "C (gcc) -trigraphs")

It's up for debate. The code is not gcc specific, its not fully standards compliant code, but on my machine cc compiles it fine with no arguments. There's just no built-in compiler on TIO that conforms to the standard by default, if there were (or an older build of gcc) then the trigraphs would just generate warnings.

Using g++ ?: extension, abuse bitwise shift modulo 32, 273 bytes

That's clever. I'm going to keep it as is however, as this version doesn't need the -trigraphs option on some C compilers, while ?: requires gcc which requires -trigraphs.

brainfuck, 635 bytes
++++++++++++++++++++++++++++++++.>+.+.+.+.<...>++++.+.+.<...>++++.+.+.+.<...>++++.+.+.+.+.<...>++++.+.+.+....++++.+.+.<...>++++.<......>+++++++.+.+.+.+.+.<......>+++++++.<...>++++.<..>+++.<...>++++.<..>+++.<......>+++++++.<......>+++++++.<...>++++.<..>+++.<......>+++++++.+.<......>+++++++.<...>++++.<..>+++.<...>++++.<..>+++.+.+.<....>+++++.<..>+++.+.<..>+++.<...>++++.<..>+++.<......>+++++++.+.+.+.<......>+++++++.<...>++++.<..>+++.<...>++++.<..>+++.<......>+++++++.<...>++++.<..>+++.<...>++++.<..>+++.<......>+++++++.<.>++.+.+.+.<...>++++.+.+.<...>++++.+.+.+.<...>++++.+.+.+.+.<...>++++.+.+.+.<...>++++.+.+.<...>++++.+.+.+.+.<..>>-.

Try it online!
In response to finally being beaten by Javascript, I have golfed what I can out of this:
1 byte saved by having 32 in cell 0 and incrementing cell 1 (the only reason I initially had it the other way was because of a quick fix when OrjanJohansen pointed out I couldn't use ])
1 byte saved by decrementing a third cell (initially at 0) to generate 255 = -1
2 bytes saved by printing spaces between characters 31 and 36 without using <> but instead simply stopping at 32 to print from cell 0 when incrementing from 31 through 33.
brainfuck, 639 bytes
>++++++++++++++++++++++++++++++++.<+.+.+.+.>...<++++.+.+.>...<++++.+.+.+.>...<++++.+.+.+.+.>...<++++.+.+.>....<+++++.+.+.>...<++++.>......<+++++++.+.+.+.+.+.>......<+++++++.>...<++++.>..<+++.>...<++++.>..<+++.>......<+++++++.>......<+++++++.>...<++++.>..<+++.>......<+++++++.+.>......<+++++++.>...<++++.>..<+++.>...<++++.>..<+++.+.+.>....<+++++.>..<+++.+.>..<+++.>...<++++.>..<+++.>......<+++++++.+.+.+.>......<+++++++.>...<++++.>..<+++.>...<++++.>..<+++.>......<+++++++.>...<++++.>..<+++.>...<++++.>..<+++.>......<+++++++.>.<++.+.+.+.>...<++++.+.+.>...<++++.+.+.+.>...<++++.+.+.+.+.>...<++++.+.+.+.>...<++++.+.+.>...<++++.+.+.+.+.>..<+++.

Try it online!
First we generate the number 32. Then we just go through incrementing one cell and switching the printing between that cell and the one containing 32. Steadily increasing numbers are something Brainfuck does well.
It's nice to beat Javascript with Brainfuck, it doesn't happen often!

Sorry, but ] isn't a permitted character. Although you should still be able to fix that and beat the Javascript. :)

@ØrjanJohansen fixed

Sorry, you lost Javascript.

@user202729 pretty good! still, I had Javascript beaten for 3 days. As I can't use loops because ] is not allowed, I think my BF answer is probably optimal now.

JavaScript (SpiderMonkey), 1918 1598 1487 1431 bytes
Saved 56 bytes thanks to @user202729
print(8<<98,7/7,9-7,7>>97,8>>97,8<<98,8<<98,8<<98,8,9,0xa,8<<98,8<<98,8<<98,0xe,0xf,7+9,8+9,8<<98,8<<98,8<<98,7+0xe,7+0xf,8+0xf,9+0xf,78^87,8<<98,8<<98,8<<98,77^80,70^88,70^89,8<<98,8<<98,8<<98,8<<98,9<<98,70^99,77>>97,8<<98,8<<98,8<<98,98-070,8<<98,8<<98,8<<98,8<<98,8<<98,8<<98,9^070,80^98,80^99,87^99,87^98,9^077,8<<98,8<<98,8<<98,8<<98,8<<98,8<<98,70-9,8<<98,8<<98,8<<98,7^70,8<<98,8<<98,9^77,8<<98,8<<98,8<<98,7^79,8<<98,8<<98,70^0xd,((8<<98)+' ').repeat(8^0xe)+(8^90),((8<<98)+' ').repeat(8^0xe)+89,8<<98,8<<98,8<<98,7^90,8<<98,8<<98,7+89,((8<<98)+' ').repeat(8^0xe)+(7|97),7+97,((8<<98)+' ').repeat(8^0xe)+(77|98),8<<98,8<<98,8<<98,80|99,8<<98,8<<98,8^0x7e,8<<98,8<<98,8<<98,0x7a,8<<98,8<<98,0x7d,0x7e,0x7f,8<<98,8<<98,8<<98,8<<98,7+0x7d,8<<98,8<<98,0x87,0x88,8<<98,8<<98,0x8b,8<<98,8<<98,8<<98,0x8f,8<<98,8<<98,7+0x8b,((8<<98)+' ').repeat(8^0xe)+0x99,0x9a,0x9b,0x9c,((8<<98)+' ').repeat(8^0xe)+(7+0x9c),8<<98,8<<98,8<<98,0xa7,8<<98,8<<98,0xaa,8<<98,8<<98,8<<98,0xae,8<<98,8<<98,78+99,((8<<98)+' ').repeat(8^0xe)+0xb8,8<<98,8<<98,8<<98,0xbc,8<<98,8<<98,0xbf,8<<98,8<<98,8<<98,97+98,8<<98,8<<98,99+99,((8<<98)+' ').repeat(8^0xe)+0xcd,8<<98,0xcf,0xd0,7+0xca,7+0xcb,8<<98,8<<98,8<<98,7+0xcf,0xd7,0xd8,8<<98,8<<98,8<<98,0xdc,0xdd,0xde,0xdf,8<<98,8<<98,8<<98,7+0xdc,7+0xdd,7+0xde,7+0xdf,0xe7,8<<98,8<<98,8<<98,0xeb,0xec,0xed,0xee,8<<98,8<<98,8<<98,7+0xeb,7+0xec,7+0xed,8<<98,8<<98,8<<98,0xf8,0xf9,0xfa,0xfb,0xfc,8<<98,8<<98,0xff)

Try it online!
How?
The fact that = is not allowed is a show-killer in JS. We can't do any variable assignment, and we also can't use any arrow function.
The above code is instead computing each number separately, using the allowed digits in either decimal, octal or hexadecimal (\$0\$, \$7\$, \$8\$, \$9\$ and 0xa to 0xf) and the following operators: +, -, /, |, ^, << and >>.
  1 = 7/7     |   50 = 80^98   |  136 = 0x88    |  216 = 0xd8
  2 = 9-7     |   51 = 80^99   |  139 = 0x8b    |  220 = 0xdc
  3 = 7>>97   |   52 = 87^99   |  143 = 0x8f    |  221 = 0xdd
  4 = 8>>97   |   53 = 87^98   |  146 = 7+0x8b  |  222 = 0xde
  8 = 8       |   54 = 9^077   |  153 = 0x99    |  223 = 0xdf
  9 = 9       |   61 = 70-9    |  154 = 0x9a    |  227 = 7+0xdc
 10 = 0xa     |   65 = 7^70    |  155 = 0x9b    |  228 = 7+0xdd
 14 = 0xe     |   68 = 9^77    |  156 = 0x9c    |  229 = 7+0xde
 15 = 0xf     |   72 = 7^79    |  163 = 7+0x9c  |  230 = 7+0xdf
 16 = 7+9     |   75 = 70^0xd  |  167 = 0xa7    |  231 = 0xe7
 17 = 8+9     |   82 = 8^90    |  170 = 0xaa    |  235 = 0xeb
 21 = 7+0xe   |   89 = 89      |  174 = 0xae    |  236 = 0xec
 22 = 7+0xf   |   93 = 7^90    |  177 = 78+99   |  237 = 0xed
 23 = 8+0xf   |   96 = 7+89    |  184 = 0xb8    |  238 = 0xee
 24 = 9+0xf   |  103 = 7|97    |  188 = 0xbc    |  242 = 7+0xeb
 25 = 78^87   |  104 = 7+97    |  191 = 0xbf    |  243 = 7+0xec
 29 = 77^80   |  111 = 77|98   |  195 = 97+98   |  244 = 7+0xed
 30 = 70^88   |  115 = 80|99   |  198 = 99+99   |  248 = 0xf8
 31 = 70^89   |  118 = 8^0x7e  |  205 = 0xcd    |  249 = 0xf9
 32 = 8<<98   |  122 = 0x7a    |  207 = 0xcf    |  250 = 0xfa
 36 = 9<<98   |  125 = 0x7d    |  208 = 0xd0    |  251 = 0xfb
 37 = 70^99   |  126 = 0x7e    |  209 = 7+0xca  |  252 = 0xfc
 38 = 77>>97  |  127 = 0x7f    |  210 = 7+0xcb  |  255 = 0xff
 42 = 98-070  |  132 = 7+0x7d  |  214 = 7+0xcf  |
 49 = 9^070   |  135 = 0x87    |  215 = 0xd7    |

Note: Bitwise shifts are processed modulo \$32\$. This is explicitly stated in the ECMAScript specification:

Let shiftCount be the result of masking out all but the least significant 5 bits of rnum, that is, compute rnum & 0x1F.

For instance, 8<<98 really does 8<<2 (which is \$32\$).

32 as 8<<9-7 saves a byte for each 32.

@TFeld Actually, I was adding shifts to my solver, which has just found 32 = 8<<98 (because $98 \equiv 2 \pmod{32}$). A few more expressions can be shortened this way. Still working on it.

"show-killer" or "fun-maker"?

@JonathanAllan ;-) The latter comes out of the former!

Sorry if I'm being stupid, but why are you linking to an old version of SpiderMonkey?

@SolomonUcko This is the version currently available on TIO.

Aw man, we can't use function or eval either, and I don't think there's any short way to get either eval or Function... (I was going to suggest function f()8<<98 to save 2 bytes on each space, until I noticed that o is illegal :-( )

@user202729 $6$ is not allowed, but there's probably a way to save bytes that way indeed.

Haskell, 623 617 614 594 360 342 bytes
Edit: -234 bytes thanks to @Lynn by finding a pattern encoding as a string. -18 bytes thanks to @Ørjan Johansen.
map(\i->cycle(8+8+8+8:filter(\_->" XXXX   XXX   XXXX   XXXXX   XXX    XXX   X      XXXXXX      X   X  X   X  X      X      X   X  X      XX      X   X  X   X  XXX    X  XX  X   X  X      XXXX      X   X  X   X  X      X   X  X   X  X      X XXXX   XXX   XXXX   XXXXX   XXXX   XXX   XXXXX  X"!!i>' ')(pure i))!!9)(take(0xf8+8)(iterate(9-8+)0))

Try it online!
How it works
map(\i->    )                   -- map the lambda over the
        (take(0xf8+8)           -- first 256 elements of
           (iterate(9-8+)0))    -- the list [0,1,2,....]

                                -- the lambda is:

    cycle                       -- make an infinite list by repeating the list
      8+8+8+8:                  -- wih element 32 followed by
                  pure i        -- the singleton list with 'i'
       filter                   -- but keep 'i' only if
          \_->" XXXX..."!!i>' ' -- the pattern has an 'X' at index 'i', else
                                -- remove it to make an empty list
                                -- i.e. the cycled list is, if the pattern is
                                -- a space: [32,32,32,32,32,32,32,32,32,32,...]
                                -- an 'X':  [32, i,32, i,32, i,32, i,32, i,...]
                                --                                       ^
                                --                        9th element ---/
                      !!9       -- pick the 9th element which is the result
                                -- of the lambda

You can index (id:pure(\_->8+8+8+8)) by until((||" XXXX   XXX   XXXX   XXXXX   XXX    XXX   X      XXXXXX      X   X  X   X  X      X      X   X  X      XX      X   X  X   X  XXX    X  XX  X   X  X      XXXX      X   X  X   X  X      X   X  X   X  X      X XXXX   XXX   XXXX   XXXXX   XXXX   XXX   XXXXX  X"!!i<'X').(<1))pred 1  and save a bunch of bytes.

342 bytes with filter instead of until to branch (and cycle to avoid an extra ++pure(...)).

Brain-Flak -r, 4190 4188 bytes
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()())())())())())())()<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())()<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()())()<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())()<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()())())()<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())())())()<((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))>()()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())()<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()())())())())()<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())()<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())()<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()())()<(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())>())())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())())())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())

Try it online!
This one is a little bit difficult for Brain-flak since we can't use ] or }.  Meaning the only useful characters are <>().
Here's a Haskell program that helped me write this
It just counts up skipping where spaces need to be and pushing those individually.

Is this provably optimal?

@user202729 I suspect not.  It could be though.  There is not a ton of wiggle room but I am far from being able to prove that it is optimal.  Although since we don't have {} a computer search could actually find the optimal in finite time.

I end up writing a program that generates the optimal solution, however it's a bit slower than what I expect.i Still fast enough to run, though.

@user202729 Well it wasn't optimal.  I found a shorter one.

JavaScript (SpiderMonkey), 1001 919 789 441 bytes
print(/u/.exec().map.call('0777700077700077770007777700077700007770007000000777777000000700070070007007000000700000070007007000000770000007000700700070077700007007700700070070000007777000000700070070007007000000700070070007007000000707777000777000777700077777000777700077700077777007',''.repeat.bind(Number)).map(/u/.exec().find.bind(/()/.exec().fill(Number.bind(0,88-070)).fill(/u/.exec().fill,!0),''.indexOf)).map(Map.call.bind(Map.call)))

Try it online!
Finally beats BF!!!
General idea
Convert each character of the long string string to its index or 32, depends on the value.
Array.prototype.map? How to get array
Brute force to see which objects are accessible by accessing object properties (because ] is not allowed, so only properties with name matching an identifier is accessible).
RegExp.prototype.exec returns an array-like object when there is a match. When no argument is provided, the argument defaults to undefined, so /u/.exec() matches and return an array.
Get 2 arbitrary distinct values on 2 different characters
We want to have (x,y)=>x=='0'?32:y, but we can't use =.
Instead, we're going to do
new Array(a)
    .map(x=>x=='0'?()=>32:function()this)
    .map((x,y,z)=>x.call(y,z))

We can map the string over some function, but => is not allowed, so only a few functions can be used. It may have bound this and some bound arguments (so it has the form (x,y,z)=>pre_filled_function.call(pre,filled,args,etc,x,y,z))
After considering a list of functions (repeat exec bind create map indexOf replace fill find reduce filter findIndex call bind apply), I decide that the following functions will be used (after considering all other combinations)

repeat: number -> different strings.
find: thisArg -> first element in array match.

The general idea would be:
[].map.call('07070707...', (x,y,z)=>[elem1,elem2].find(somefunction,x,y,z)

where somefunction considers the this argument (x) and the first argument (elem1 or elem2) and return whether it matches.
The last arrow function is rewritten to [].find.bind([elem1,elem2],somefunction).
Array literal
We can use regex exec to get an array, and fill it with different values. For example /()/.exec() returns a length-2 array, then we can fill it as we need.
Which somefunction do we need?
We need one that returns a truthy/falsy value depends on this (which is 1 of 2 functions we're going to return) and first argument (must be a string or array).
For that, I used indexOf -- it returns falsy value iff the first argument is a prefix of the this argument.
Represent the function literals

stumbles off end of explanation and winds up hanging off a branch

TI-Basic (83 series), 578 bytes
8XFact8-ΔTbl
seq(X and XX≤8+8 or 8≤X and X≤Xmax or 7+7≤X and X<9+9 or 7+7+7≤X and X<8π or 9π<X and X<πXmax or 9 nCr 7≤X and X+X<77 or X=7²-7 or 7²≤X and X≤7*9-9 or X=70-9 or X=8²+ΔTbl or X=78-Xmax or X=9*8 or X=89-7-7 or X=89-7 or X=89 or X=900-807 or X=88+8 or 809-707<X and X≤97+77-70 or 9X=999 or 8X=990-70 or X=888-770 or X=899-777 or 8*7+77-8≤X and X+X<Ans or 7²X/77=77+7 or 999+77<8X and 7X<970-9-7 or 8²X=8888+8 or X+X=99+99+88 or 7X=9099-8077 or 9+8≤X/9 and X<997-770-70 or X=99+8² or X=87+80 or X=80+90 or X=87+87 or X=87+90 or X=87+97 or X=98+90 or X=999-808 or X=97+98 or X=99+99 or X=99+99+7 or 9²8<πX and X+X+X≤70*9 or 70π-π-π<Xand X+X+X≤9²8 or 70π<X and X<70π+π or 997-770≤X and X+X+X≤99*7 or 77+79+79≤X and X+8+9≤Ans or 77π<X and X<Ans-Xmax or 7*8*9-8≤X+X and X+X≤7*8*9 or X=Ans,X,0,Ans
8XFact+Ansseq(X,X,⁻8XFact,70π+π

TI-Basic has its own very special "code-page" with weird design choices like moving the space character over to 0x29 so that 0x20 can be the randM( command.
It's tricky to figure out how to get TI-Basic to output the right kind of object. Strings wouldn't work for multiple reasons: there's no way to reference a token without using the token, and also we're not allowed the " character. We can't just write a list, because { and } are forbidden. We are allowed the [ and ] characters for matrices, but a 1 by 256 matrix doesn't work, since matrices are allowed at most 99 rows and columns. We can't use → to assign to variables, and we can't get at the list variables ʟ or L₁ through L₆ anyway.
So here, we write down a complicated logical formula with inequalities that says when a character is one of the ones we want to output. Then we use the seq( command to generate a list with 1 in those positions and 0 elsewhere. From there, another seq( command and some arithmetic finishes the job.
That was the exciting part; the rest is golfing the constants and I probably haven't done that as much as possible. One of the tricks I use is that by default, Xmax is 10, XFact is 4, and ΔTbl is 1.

While a 1256 matrix won't work, can you make something like a 399 matrix and use div/mod to index the matrix?

Oh, we also can't index things, because ( is forbidden.

Is there conditional expression (if a then b else c) or floor or mod? Number precision is ~15 decimal digits right?

All of these exist. We just can't get at a matrix entry with [A](I,J), and from what I understand you want to do something like [A](int(I/99),I-99int(I/99)) to read out all the elements of the matrix [A] - we also can't do that. (By the way, ) is also forbidden. Fortunately, we don't have to close ending parentheses, but it limits how we can use many commands.)

I am thinking about using a number to encode an array, similar to a bitmask. Like (123456789>>X)&1 in Python.

@user202729 I worked on this for a while and came up with a much better answer, then realized it was doomed because augment( (the list-joining command) is forbidden, so we can't construct the array in 8 blocks we can encode by integers. Trying to do it at once with some fake-conditional expression seems to require parentheses.

Hm. Because ) is disallowed, the conditional must have no open-parentheses. So only operators (^, x√, ×, ÷, +, -, ...) can be used. Is there a way to compute mod or int/fractional part without parentheses?

commands have their own ( built in, and you don't need ) at the end of a line, so you can use int( and fPart( at least some of the time. If we're building a list using seq(, we can apply these to the whole list at once, but we can't have them inside the seq( expression.

So you're using something like int(2×fPart(seq(1.23456789×2^X? /// The floating point precision of the calculator is finite, so X+1E14-1E14 (or similar) may be equivalent to int(X).

Something like that - this lets us encode something like 30-ish bits in a single number, so I tried using 32 bits so that we'd have 8 blocks. And it is in fact not too hard to write down 8 seq( commands that give us length-32 parts of the length-256 list we actually want. But then we can't glue them back together into one list, because augment( is a forbidden byte. And we can't write down one seq( command to begin with because of the precision issue.

Because and cast its arguments to integers, it might be possible to use and 1 to get the last bit, so the expression may look like 1.246...÷2^X and 1 or 2.12...÷2^X and 1 or ...

and doesn't cast its arguments to integers in any useful way: it will convert every nonzero real number to 1, whereas what we want here is to distinguish between, say, numbers in [0,0.5] and numbers in [0.5,1].

Oops... then try using iPart(2×-seq(-fPart(1.234....÷2^X)-...., where -fPart(X) = X+E13-E13-X.

Brain-Flak -r, 3894 bytes
(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())<((())((()())()))>)))(((((((()()()()()()()())(()()()()()()()()())(()()()()()()()()()())()()()()())))<((((((((()()()()()()()()()()()()()())((((((((((()()()()()()()()()()()()()()())((()()()()()()()()()()()()()()()())()))))<((((((((((((()()()()()()()()()()()()()()()()()()()()())())())())())()()()()()()())))<((((((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()())())())()))))()()()())())())>)))()()()()()()()()()())>))))))()()())())())())())())<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()()())>)))())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()()())<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()()())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()()())())<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()()())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())())())<((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))>()()()()())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()()())())())())<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()()())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()()())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()()())<(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())>()())())())())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())())())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())())())())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())())())())())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())())())())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())())())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())())())())())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())

Try it online!
I wrote a program to generate the optimal Brain-Flak program for any output. Assume that:

<> is not used
My program is correct

, then this solution is optimal.
However, I was a bit lazy and implement a solution that is not very hard to come up with, and it ends up running in 1m13s (takes time \$O(n^5)\$ or so). I may look for more efficient solution later.

Python 2, 162 157 bytes
Warning: Unprintable characters ahead!
print map(lambda(i,x):(x>'0'and i-0xe0/7)+0xe0/7,enumerate(bin(reduce(lambda x,y:(x<<0xd-7)-x+y,bytearray('7?QcZ;+BqiQJUS!?B0W![<LBU7X!frQd(SQdB\0')))))

Try it online!
Based on TFeld's existing answer, but with a few changes:

Use 0xe0/7 instead of 8+8+8+8 to represent 32. (a program to find shortest representation of a number)
Use a bytearray to represent the huge literal.

A bytearray is similar to a str that it's iterable, however, iterating it gives integers, not characters. We can use it to encode a base-N literal and reduce(lambda x,y: x*N+y, my_bytearray) to decode it.
Because Python 2 files don't have an encoding by default, only characters in ASCII (0..127) can be used. Null byte, newlines, backslashes and quotes take 1 more byte.
Also, it's not possible to use all bases.
I wrote a program to find the shortest representation of n, given those restrictions.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Number of rotations
Task
Write a function or a program to find the number of rotations required by a wheel to travel a given distance, given its radius.
Rules
Input can be 2 positive rational numbers and can be taken in any convenient format.
Both inputs are of same unit.
There must not be any digits 0-9 in your code.
The output will be an integer (in case of float, round to infinity)
This is code-golf so shortest code wins
Examples
distance radius  output
10       1       2
50       2       4
52.22    4       3
3.4      0.08    7
12.5663  0.9999  3

You probably should add that digits are also forbidden in compiler options (or anywhere else): if you limit this constraint to code only, with gcc we can do something like -DP=3.14 in compiler flags, that would define P as an approximation of pi, which is probably not what you intended

MathGolf, 5 4 bytes
τ/╠ü

Try it online!
Explanation
τ      Push tau (2*pi)
 /     Divide the first argument (total distance) by tau
  ╠    Reverse divide (computes (distance/tau)/radius)
   ü   Ceiling

Java 8, 32 30 bytes
a->b->-~(int)(a/b/Math.PI/'')

Contains unprintable \u0002 between the single quotes.
Port of @jOKing's Perl 6 answer.
Try it online.

Is that the digit '1' in your code? I think that might not be allowed.

@ouflak Looks like it can be fixed like this.

@ouflak Woops, that was a pretty stupid mistake.. Using the unprintable so I don't use the digit 2, and then just use digit 1... Luckily Erik is indeed right that a simple negative unary has the same effect as +1 (often used to get rid of parenthesis since the negative and unary have higher precedence than most other operators).

Perl 6, 15 12 bytes
-3 bytes tjanks to nwellnhof reminding me about tau
*/*/τ+|$+!$

Try it online!
Anonymous Whatever lambda that uses the formula (a/b/tau).floor+1. Tau is two times pi. The two anonymous variables $ are coerced to the number 0, which is used to floor the number +|0 (bitwise or 0) and add one +!$ (plus not zero).

There must not be any digits 0-9 in your code.

@Titus I can't believe I forgot that. Thanks, fixed!

Are digits in exponents also allowed?

APL+WIN, 9 bytes
Prompts for radius followed by distance:
⌈⎕÷○r+r←⎕

Try it online!  Courtesy of Dyalog Classic
Explanation:
○r+r←⎕ prompt for radius and double it and multiply by pie

⌈⎕÷ prompt for distance, divide by result above and take ceiling

⌈⎕÷○+⍨⎕ works for 7 bytes.

@J.Sallé Thanks but unfortunately my ancient APL+WIN interpreter does not have the ⍨ operator

Python 2, 47 45 44 43 bytes
lambda l,r:l/(r+r)//math.pi+l/l
import math

Try it online!

-2 bytes, thanks to flawr
-1 byte, thanks to Jonathan Allan

Since inputs have been guaranteed to be both (strictly) positive and rational we never hit the edge-case of requiring an exact number of rotations, so I think we can do l/(r+r)//pi+l/l and save a byte.

@JonathanAllan Thanks :)

05AB1E, 6 bytes
·/žq/î

Port of @flawr's Python 2 comment.
Takes the input in the order radius,distance.
Try it online or verify all test cases.
Explanation:
·         # Double the first (implicit) input
 /        # Divide the second (implicit) input by it
  žq/     # Divide it by PI
     î    # Ceil it (and output implicitly)

MathGolf, 6 5 bytes
∞/π/ü

Semi-port of @flawr's Python 2 comment.
Takes the input in the order radius distance.
-1 byte because ceil builtin has just been added, replacing the floor+1.
Try it online.
Explanation:
∞        # Double the first (implicit) input
 /       # Divide the second (implicit) input by it
  π/     # Divide it by PI
    ü    # Ceil (and output implicitly)

PHP, 47 bytes
<?=ceil($argv[++$i]/M_PI/(($b=end($argv))+$b));

Try it online.

Ruby, 29 bytes
->l,r{(l/Math::PI/r+=r).ceil}

Try it online!

Catholicon, 8 bytes
ċ//ĊǓĊ`Ė

Explanation:
  /ĊǓĊ    divide the first input by the doubled second input
 /    `Ė  divide that by pi
ċ         ceil

New version (pi builtin made one byte, division parameters swapped), 5 bytes
ċ/π/Ǔ

C, 46 bytes
f(float a,float b){return ceil(a/(b+b)/M_PI);}

I'm new to PPCG, so I'm not sure wether I have to count other parts in the byte count, such as the
include <math.h>

needed for the ceil function, which will rise the count to 64 bytes

Welcome to PPCG! This is a nice first answer. Yes, you do need to count #include and the like towards your byte total. A link to an online test suite is always appreciated, here's one you are free to incorporate into your post: https://tio.run/##bY5BC4IwHMXP9Sn@FMGGc9OppRjdOwR9gCDmdDWYK2wdQvrqrSLp5Okdfj/eezI8Senn2kpzrxtYt8Kd6XkDjEEAcQ7VwzU3r5AyF@FAkF9WuO8ad@8syEYbJBiqggqz3XG/xeXTt0JbhKGfTq6dtk6h2aI@2BkBheKIQIxx@R3gIzz7cD7wdIxzyjmBdFCSESWhKYGIRvngrMZucJotl8nXK4riX/b0L6mMON18aNo3

@O.O.Balance Digits are not allowed in the code for this challenge ;)

@Annyo I knew I was forgetting something :(

J, 10 9 bytes
>.@%o.@+:

Try it online!

Stax, 5 bytes
Vt*/e

Run and debug it
Vt*   multiply by tau (2pi)
/     divide
e     ceiling

C (gcc), 45 47 45 bytes
f(d,r,R)float d,r;{R=ceil(d/r/'G'/'\n'*'q');}

A reasonable approximation of pi is 355/113. Since circumference C = 2 * r * PI, we can instead of pi use tau, which is then of course ~710/113. 710 happens to have the convenient factors 2 * 5 * 71, which is compactly expressed as 'G' * '\n'. We add one (r/r) to force rounding to infinity.
Edit: My trick was too clever for its own good: it of course made it fail if the distance was a multiple of the circumference.
Try it online!

Julia 1.0, 20 bytes
f(d,r)=cld(d/π,r+r)

Try it online!

R, 39 32 bytes
-7 bytes Thanks to Giuseppe
function(d,r)ceiling(d/(r+r)/pi)

Try it online!
I feel like this could definitely be golfed, but I am a bit lazy right now to do anything about it

min, 16 bytes
/ tau / ceil int

Takes the distance and radius put on the stack in that order. Then divides by tau, rounds, and makes int.

JavaScript (Babel Node), 25 bytes
-2 bytes using @flawr comment =D. -1 from @Kevin. -7 from @Shaggy
a=>b=>-~(a/(b+b)/Math.PI)

Try it online!

Just a=>b=>Math.ceil(a/(b+b)/Math.PI) is 32 bytes. :)

25 bytes

Jelly, 6 bytes
÷÷ØPHĊ

Try it online!

Lua, 61 58 57 49 bytes
function(s,r)return math.ceil(s/(r+r)/math.pi)end

Try it online!
Thanks to KirillL. -8 bytes.

I don't know much Lua (so maybe it's still too long), but it appears to be shorter as a function: 49 bytes

@KirillL., I'm still learning the rules here. The OP's challenge is pretty open on the input. So my question is, would we have to count your program call() against the byte count? If not, your's definitely shaves off a nice chunk.

A quite common style of submission here is an anonymous function (so that we don't have to count the name, unless it is recursive), which outputs by its return value. The footer section with function calls and actual printing to console is then basically used for visualizing the results and doesn't count towards your score. BTW, you may add more of the OP's test examples to the footer, so that they can be conveniently viewed all at once. Note that in some cases a full program may actually turn out to be golfier!

Japt, 7 bytes
/MT/V c

Try it here

Dart, 47 46 bytes
import'dart:math';f(a,b)=>(a/(b+b)/pi).ceil();

Try it online!

-1 byte thanks to @Shaggy

46 bytes

Haskell, 25 bytes
f d r=ceiling(d/(r+r)/pi)

You can define an operator (!) instead of f and use ceiling$ instead of ceiling(..)which saves you 3 bytes: Try it online!

Common Lisp, 36 bytes
(lambda(a b)(ceiling(/ a(+ b b)pi)))

Try it online!

Tcl, 50 bytes
proc N d\ r {expr ceil($d/(($r+$r)*acos(-$r/$r)))}

Try it online!

Tcl, 53 bytes
proc N d\ r {expr ceil($d/(($r+$r)*acos(-[incr i])))}

Try it online!

Lack of a pi constant or function makes me lose the golf competition!

Do I need to remove the .0 at end of each output? It would make me consume more bytes!

[incr i] is quite clever but I think you can use $d/$d or $r/$r instead.

Saved some bytes thanks to @david's idea!

PowerShell, 53 52 51 bytes
-1 byte thanks to @mazzy-1 byte after I realized I don't need a semicolon after the param() block
param($d,$r)($a=[math])::ceiling($d/($r+$r)/$a::pi)

Try it online!
Takes input from two commandline parameters, distance -d and radius -r.

? param($d,$r);($a=[math])::ceiling($d/($r+$r)/$a::pi)

Pari/GP, 23 19 bytes
(d,r)->-d/(r+r)\-Pi

Try it online!

Desmos, 22 bytes
f(d,r)=ceil(d/π(r+r))

Try it on Desmos!

JavaScript (Babel Node), 23 bytes
s=>r=>-~(s/2/r/Math.PI)

Try it online!

There must not be any digits 0-9 in your code.

Clojure, 50 bytes
(fn[a b](int(Math/ceil(/ a Math/PI(count"  ")b))))

An anonymous function that accepts two integers a and b as arguments: the distance and the wheel's radius, respectively.
Try it online!
(count "  ") evaluates to 2, so this function implements \$\lceil \dfrac a{2\pi b} \rceil\$.

TI-Basic (83 series), 12 bytes
-int(-Tmax⁻¹min(e^(ΔList(ln(Ans

Takes input as a list of radius and distance in Ans: for example, {0.9999:12.5663:prgmX.
e^(ΔList(ln(Ans will take the ratio of those distances, and min( turns this into a number. Then we divide by Tmax, which is a graphing parameter that's equal to 2π by default. Finally, -int(- takes the ceiling.

SmileBASIC, 28 bytes
INPUT D,R?CEIL(D/(R+R)/PI())

Intel 8087 FPU assembly, 22 bytes
; input: D,R (shortreal,shortreal)
; output: O (memsixteen)
FDIST   MACRO  D, R, O
    FLD  D      ; ST[] = D
    FLDPI       ; ST[] = PI
    FDIV        ; ST = D / PI
    FLD  R      ; ST[] = R
    FLD  ST     ; ST[] = R
    FADD        ; ST = R + R
    FDIV        ; ST = D / PI / R + R
    FISTP O
        ENDM

Uses only the Intel Eighty-Eighty-Seven math-coprocessor.  Inputs Distance (D) and Radius (R) as thirty-two bit IEEE Seven-Fifty-Four single-precision real. Returns O as a sixteen bit unsigned int.

Ruby, 31 bytes
->d,r{d/=Math::PI*(r+r);d.ceil}

Try it online!

Factor + cursors, 18 bytes
[ / pi pi + up/i ]

Try it online!
Divide the distance by the radius, then ceiling-integer-divide that by 2pi. The ceiling-integer-division word up/i is provided by the cursors vocabulary.