27
\$\begingroup\$

Display numbers from one to one-hundred (in increasing order), but number 2 shouldn’t appear anywhere in the sequence. So, for example, the numbers two (2) or twenty-three (23) shouldn't be in the sequence.

Here is an example output, with newlines separating the numbers:

1
3
4
5
6
7
8
9
10
11
13
14
15
16
17
18
19
30
31
33
34
35
36
37
38
39
40
41
43
44
45
46
47
48
49
50
51
53
54
55
56
57
58
59
60
61
63
64
65
66
67
68
69
70
71
73
74
75
76
77
78
79
80
81
83
84
85
86
87
88
89
90
91
93
94
95
96
97
98
99
100
\$\endgroup\$
18
  • 7
    \$\begingroup\$ I assume the winning criteria is code-golf right? \$\endgroup\$ Commented Oct 2, 2018 at 13:26
  • 4
    \$\begingroup\$ Our site does not work the same way as other sites from the Stack Exchange network. Regarding accepted answers, please take this comment from Jonathan Allan into account. And please add a winning criterion. \$\endgroup\$
    – Arnauld
    Commented Oct 2, 2018 at 14:08
  • 2
    \$\begingroup\$ Might I suggest using the Sandbox in the future to get feedback on your challenges before posting? \$\endgroup\$
    – Jo King
    Commented Oct 2, 2018 at 14:15
  • 1
    \$\begingroup\$ @Monolica If the shortest answer wins, you'll need the tag [code-golf]. Here is a list for all available winning criteria tags for future reference. \$\endgroup\$ Commented Oct 2, 2018 at 14:19
  • 4
    \$\begingroup\$ @user202729 Arbitrary restriction is unwelcome, not disallowed. \$\endgroup\$ Commented Oct 3, 2018 at 1:11

76 Answers 76

26
\$\begingroup\$

Taxi, 2399 2391 2370 1783 1773 1706 bytes

-8 bytes for realizing that, instead of leaving a certain passenger at Sunny Side Park forever, it's more worth it to throw them off of Riverview Bridge. Ah, what a lovely town this is.

-21 bytes for taking out a comment I stupidly left in.

-587 bytes by simply changing the entire way I went about this (apparently a shorter way is by arithmetic; integer-dividing [17, 27, 37, 47,...] by 9 yields the sequence, but you gotta skip over the 20's yourself.)

-17 bytes for the realization that any quotes-encased string without a space doesn't need quotes after all (thanks Jo King!).

-67 bytes for the realization that linebreaks are optional.

17 is waiting at Starchild Numerology.Go to Starchild Numerology:w 1 l 2 r 1 l 1 l 2 l.Pickup a passenger going to Cyclone.Go to Cyclone:e 1 l 2 r.[B]Pickup a passenger going to Cyclone.Pickup a passenger going to Divide and Conquer.9 is waiting at Starchild Numerology.Go to Starchild Numerology:s 2 l 2 r.Pickup a passenger going to Divide and Conquer.Go to Divide and Conquer:e 1 l 2 r 3 r 2 r 1 r.Pickup a passenger going to Trunkers.Go to Trunkers:e 1 r 3 r 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:e 1 r 1 r.Pickup a passenger going to Post Office.\n is waiting at Writer's Depot.Go to Writer's Depot:n 5 l 2 l.Pickup a passenger going to Post Office.Go to Post Office:n 1 r 2 r 1 l.Go to Cyclone:s 1 r 1 l 2 r.Pickup a passenger going to Addition Alley.Pickup a passenger going to Equal's Corner.177 is waiting at Starchild Numerology.Go to Starchild Numerology:s 2 l 2 r.Pickup a passenger going to Equal's Corner.Go to Equal's Corner:w 1 l.Switch to plan C if no one is waiting.Pickup a passenger going to Sunny Skies Park.100 is waiting at Starchild Numerology.Switch to plan D.[C]10 is waiting at Starchild Numerology.[D]Go to Starchild Numerology:n 1 r.Pickup a passenger going to Addition Alley.Go to Sunny Skies Park:w 1 r.Go to Addition Alley:n 1 r 1 r 1 r.Pickup a passenger going to Cyclone.Go to Cyclone:n 1 l 1 l.Pickup a passenger going to Cyclone.Pickup a passenger going to Equal's Corner.917 is waiting at Starchild Numerology.Go to Starchild Numerology:s 2 l 2 r.Pickup a passenger going to Equal's Corner.Go to Equal's Corner:w 1 l.Switch to plan E if no one is waiting.Switch to plan F.[E]Go to Go More:n 1 l.Go to Cyclone:w 1 r.Switch to plan B.[F]

Try it online!

This one isn't winning me any code golf competitions anytime soon, but I decided to try out the esolang Taxi.

Taxi is an esolang in which all programming is done by picking up and dropping off passengers at various stops in the fictional town of Townsburg. Of course, your taxicab will sometimes run out of gas, so you also need to visit gas stations every so often, and pay using the credits you receive as fare (in this case, I only need to stop for gas - at Go More - once per loop iteration!).

I used some tricks that reduce the filesize a bit, such as rephrasing directions like east 1st left, 2nd right as e 1 l 2 r, removing the word the where it is optional, and using the least complicated route towards all of my destinations (not necessarily the shortest path).

I hate this shorter solution more than the one I originally came up with. This solution down here is a more general way of accomplishing the task, which could start and end anywhere you want. Here it is, in its entirety.

2245 bytes (way more general)

1 is waiting at Starchild Numerology.Go to Starchild Numerology:w 1 l 2 r 1 l 1 l 2 l.Pickup a passenger going to Cyclone.Go to Cyclone:e 1 l 2 r.[B]Pickup a passenger going to Addition Alley.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:n 2 r 2 r.Pickup a passenger going to Cyclone.Go to Cyclone:n 5 l 2 l.Pickup a passenger going to Chop Suey.Go to Zoom Zoom:n.0 is waiting at Writer's Depot.Go to Writer's Depot:w.Pickup a passenger going to Narrow Path Park.Go to Narrow Path Park:n 3 r 1 l 1 r.Go to Chop Suey:e 1 r 1 l 1 r.[C]Switch to plan E if no one is waiting.Pickup a passenger going to Crime Lab.2 is waiting at Writer's Depot.Go to Writer's Depot:n 1 l 3 l.Pickup a passenger going to Crime Lab.Go to Crime Lab:n 3 r 2 r.Switch to plan D if no one is waiting.Pickup a passenger going to KonKat's.Go to Narrow Path Park:n 5 l.Pickup a passenger going to KonKat's.Go to KonKat's:e 1 r.Pickup a passenger going to Narrow Path Park.Go to Narrow Path Park:n 2 l.Go to Chop Suey:e 1 r 1 l 1 r.Switch to plan C.[D]Go to Chop Suey:n 5 r 1 l.Switch to plan C.[E]Go to Narrow Path Park:n 1 l 1 r 1 l.Pickup a passenger going to Crime Lab.0 is waiting at Writer's Depot.Go to Writer's Depot:w 1 l 1 r 2 l.1 is waiting at Starchild Numerology.Pickup a passenger going to Crime Lab.Go to Crime Lab:n 3 r 2 r.Switch to plan F if no one is waiting.Pickup a passenger going to Riverview Bridge.Go to Cyclone:n 4 l 2 l.Pickup a passenger going to Post Office.Go to Riverview Bridge:n 2 r.\n is waiting at Writer's Depot.Go to Writer's Depot:w 2 l.Pickup a passenger going to Post Office.Go to Post Office:n 1 r 2 r 1 l.Go to Starchild Numerology:s 1 r 1 l 1 l 2 l.Switch to plan G.[F]Go to Cyclone:s 1 r 1 l 2 r.Pickup a passenger going to Riverview Bridge.Go to Riverview Bridge:n 2 r.Go to Starchild Numerology:w 2 l 3 l 2 r.[G]Pickup a passenger going to Addition Alley.Go to Addition Alley:e 1 l 2 r 3 r 1 r.Pickup a passenger going to Magic Eight.101 is waiting at Starchild Numerology.Go to Starchild Numerology:n 1 l 1 l 3 l 2 r.Pickup a passenger going to Magic Eight.Go to Magic Eight:w 1 r 2 r 1 r.Switch to plan H if no one is waiting.Pickup a passenger going to Cyclone.Go to Cyclone:n 1 l 2 r.Switch to plan B.[H]

Try it online!

And if mega-cheating is allowed, this one is way shorter than either of the last two.

456 bytes (totally cheating)

1\n3\n4\n5\n6\n7\n8\n9\n10\n11\n13\n14\n15\n16\n17\n18\n19\n30\n31\n33\n34\n35\n36\n37\n38\n39\n40\n41\n43\n44\n45\n46\n47\n48\n49\n50\n51\n53\n54\n55\n56\n57\n58\n59\n60\n61\n63\n64\n65\n66\n67\n68\n69\n70\n71\n73\n74\n75\n76\n77\n78\n79\n80\n81\n83\n84\n85\n86\n87\n88\n89\n90\n91\n93\n94\n95\n96\n97\n98\n99\n100 is waiting at Writer's Depot.Go to Writer's Depot:w 1 l 2 r 1 l 2 l.Pickup a passenger going to Post Office.Go to Post Office:n 1 r 2 r 1 l.

Try it online!

\$\endgroup\$
3
  • \$\begingroup\$ That quotes thing is a helpful one, thanks. However, I disagree with the "don't have to go to the Taxi Garage" thing. Is exiting with an error allowed? I can't find a good set of general rules on this. \$\endgroup\$ Commented Oct 5, 2018 at 17:11
  • 1
    \$\begingroup\$ Yeah, generally STDERR is ignored. Relevant meta \$\endgroup\$
    – Jo King
    Commented Oct 5, 2018 at 21:28
  • \$\begingroup\$ Some of my answers could benefit from that. \$\endgroup\$ Commented Oct 5, 2018 at 21:56
24
\$\begingroup\$

Python 2, 39 bytes

k=7
exec"k+=10;print(k>177)*10+k/9;"*81

Try it online!

Uses arithmetic operations only to generate numbers without 2's.

The value k follows the arithmetic progression 17, 27, 37, 47, ..., which when floor-divided by 9 gives 1,3,4,5,6,7,8,9,10,11,13,14,... which counts up numbers not ending in 2. To skip 20 through 29, outputs are increased by 10 past a certain threshold.

\$\endgroup\$
1
  • \$\begingroup\$ +1 clever use of the arithmetic progression!! \$\endgroup\$
    – DialFrost
    Commented Oct 12, 2022 at 5:25
14
\$\begingroup\$

JavaScript (ES6), 43 bytes

Returns the sequence as a comma-separated string.

f=(n=98)=>n?f(n-=n-27?n%10?1:2:11)+[,n+3]:1

Try it online!

Why doing it this way?

We could iterate from \$1\$ to \$100\$ and test each number with /2/.test(n), which is a rather concise statement. But in this scenario, we'd have to handle empty entries with something like (/2/.test(n)?'':...), which adds a couple more bytes.

For example, this would work for 45 bytes:

f=(n=1)=>n>99?n:(/2/.test(n)?'':[n,,])+f(n+1)

Or this would work for 44 bytes, if a leading comma is acceptable:

f=(n=100)=>n?f(n-1)+(/2/.test(n)?'':[,n]):''

All in all (and until proven otherwise), it turns out to be shorter to skip right away all values of \$n\$ that contain a \$2\$.

Commented

f =                 // f is a recursive function taking:
(n = 98) =>         // n = counter, initialized to 98
  n ?               // if n is not equal to 0:
    f(              //   prepend the result of a recursive call:
      n -=          //     update n:
        n - 27 ?    //       if n is not equal to 27:
          n % 10 ?  //         if n is not a multiple of 10:
            1       //           subtract 1 from n
          :         //         else:
            2       //           subtract 2 from n
        :           //       else (n = 27):
          11        //         subtract 11 from n (--> 16)
    ) +             //   end of recursive call
    [, n + 3]       //   append a comma, followed by n + 3; notice that this is the value
                    //   of n *after* it was updated for the recursive call; at the first
                    //   iteration, we have: n = 98 -> updated to 97 -> n + 3 = 100
  :                 // else (n = 0):
    1               //   output the first term '1' and stop recursion
\$\endgroup\$
2
  • 1
    \$\begingroup\$ This is so cool! \$\endgroup\$
    – Emigna
    Commented Oct 2, 2018 at 20:02
  • 1
    \$\begingroup\$ 41 bytes using your trick if we could have a leading comma. \$\endgroup\$
    – Oliver
    Commented Oct 3, 2018 at 1:22
13
\$\begingroup\$

05AB1E, 6 bytes

тLʒ2å_

Try it online!

Explanation

тL       # push [1 ... 100]
  ʒ      # filter, keep only elements that
   2å_   # does not contain 2
\$\endgroup\$
12
\$\begingroup\$

R, 19 bytes

grep(2,1:100,inv=T)

Try it online!

\$\endgroup\$
5
  • \$\begingroup\$ grep(2,1:100,inv=T) for 19. \$\endgroup\$
    – J.Doe
    Commented Oct 2, 2018 at 18:34
  • 2
    \$\begingroup\$ Ha - this was what I tried at first but with v=F as well because obviously, I thought to myself, I want the values and not the indices...duh! \$\endgroup\$
    – ngm
    Commented Oct 2, 2018 at 19:02
  • \$\begingroup\$ Inverting the regex itself is a byte shorter (in this case). \$\endgroup\$
    – ngm
    Commented Oct 2, 2018 at 19:23
  • \$\begingroup\$ Doesn't work, still lets 2s past. You'd need ^[^2]*$ which is, um, not shorter. \$\endgroup\$
    – J.Doe
    Commented Oct 2, 2018 at 19:24
  • 4
    \$\begingroup\$ What, are we supposed to check our answers now? \$\endgroup\$
    – ngm
    Commented Oct 2, 2018 at 19:25
10
\$\begingroup\$

Python 2, 44 bytes

print[n for n in range(1,101)if'2'not in`n`]

Try it online!

\$\endgroup\$
10
\$\begingroup\$

Perl 6, 22 bytes

put grep {!/2/},1..100

Try it online!

There's probably a better way to do the code block, but I couldn't find a regex adverb to invert the match

\$\endgroup\$
3
  • \$\begingroup\$ remove the brackets around the numbers. Otherwise it is fine. \$\endgroup\$
    – Monolica
    Commented Oct 2, 2018 at 14:01
  • \$\begingroup\$ @Monolica Fixed \$\endgroup\$
    – Jo King
    Commented Oct 2, 2018 at 14:05
  • 1
    \$\begingroup\$ @Monolica It seems a little weird that you singled my answer out as not allowed to print as a list, where so many other answers do so. On the other hand, it doesn't cost me any bytes, so whatever \$\endgroup\$
    – Jo King
    Commented Oct 3, 2018 at 6:33
7
\$\begingroup\$

Bash + GNU utilities, 16

  • 1 byte saved thanks to @Dennis.
seq 100|sed /2/d

Try it online!

\$\endgroup\$
0
7
\$\begingroup\$

PowerShell, 22 16 bytes

1..100-notmatch2

Try it online!

-6 bytes thanks to mazzy

Generates the range 1 to 100, then pulls out those objects where they do -notmatch the number 2. Running the -notmatch against an array like this acts like a filter on the array. Each item is left on the pipeline, and output is implicit.

\$\endgroup\$
2
  • \$\begingroup\$ ? 1..100-notmatch2 \$\endgroup\$
    – mazzy
    Commented Oct 3, 2018 at 11:51
  • \$\begingroup\$ @mazzy Of course, why didn't I think of that? Thanks! \$\endgroup\$ Commented Oct 3, 2018 at 12:26
6
\$\begingroup\$

Haskell, 48 33 31 bytes

Thanks @JonathanFrech for fifteen bytes saved, and @xnor for another two! I missed a big golf and didn't realize main=print$ can be omitted.

filter(all(/='2').show)[1..100]

Try it online!

Easily extended by changing the 100. Stringifies all the numbers and keeps only those without a '2'.

\$\endgroup\$
3
  • \$\begingroup\$ See this; the main=print$ is not necessary. Have you tested your code? I do not think that elem'2' is valid syntax. Why map? Simply filter(not.elem '2'.show)[1..100] does the job. \$\endgroup\$ Commented Oct 3, 2018 at 1:04
  • \$\begingroup\$ @JonathanFrech Wow, missed that. :/ No clue where that space went! It's there in the TIO... \$\endgroup\$ Commented Oct 3, 2018 at 1:31
  • 2
    \$\begingroup\$ Haskell has notElem for not.elem, but even shorter is all(/='2'). \$\endgroup\$
    – xnor
    Commented Oct 3, 2018 at 1:47
6
\$\begingroup\$

Japt, 7 bytes

Lõs kø2

Lõs kø2     Full Program
Lõs         Range ["1"..."100"] (numbers are casted to string)
    k       Remove
     ø2     anything that contains "2"

Try it online!

\$\endgroup\$
5
\$\begingroup\$

Java 10, 67 bytes

v->{for(int i=0;++i<101;)if(i%10!=2&i/10!=2)System.out.println(i);}

Try it online.

Explanation:

v->{                           // Method with empty unused parameter and no return-type
  for(int i=0;++i<101;)        //  Loop `i` in the range (0, 101)
    if(i%10!=2                 //   If `i` modulo-10 is not 2
       &i/10!=2)               //   And `i` integer-divided by 10 is not 2 either
      System.out.println(i);}  //    Print `i` with a trailing newline
\$\endgroup\$
5
\$\begingroup\$

Retina, 19 17 bytes


100*
.
$.>`¶
A`2

Try it online! Edit: Saved 2 bytes thanks to @ovs, although the last line now includes a newline. Explanation:


100*

Insert 100 characters.

.
$.>`¶

Replace each character with the number of characters up to and including that character, plus a newline.

A`2

Remove all entries that contain a 2.

\$\endgroup\$
2
  • \$\begingroup\$ Does . $.>`¶ work for the second stage? \$\endgroup\$
    – ovs
    Commented Oct 3, 2018 at 13:41
  • \$\begingroup\$ @ovs I had had something more complicated before and switched to L$ to avoid a leading newline, so I hadn't realised I could switch back, thanks. \$\endgroup\$
    – Neil
    Commented Oct 3, 2018 at 16:40
5
\$\begingroup\$

Tcl, 44 bytes

time {if ![regexp 2 [incr i]] {puts $i}} 100

Try it online!


Tcl, 47 bytes

time {if [incr i]%10!=2&$i/10!=2 {puts $i}} 100

Try it online!

Tcl, 50 bytes

time {if {2 ni [split [incr i] ""]} {puts $i}} 100

Try it online!

\$\endgroup\$
3
  • \$\begingroup\$ # Tcl, 49 bytes time {if [string f 2 [incr i]]==-1 {puts $i}} 100Failed outgolf! \$\endgroup\$
    – sergiol
    Commented Oct 3, 2018 at 9:45
  • \$\begingroup\$ You could replace your test with a regexp: ![regexp 2 [incr i]] for -3 bytes \$\endgroup\$
    – david
    Commented Nov 23, 2018 at 5:59
  • \$\begingroup\$ @david How was it possible I didn't come with the solution suggested by you of using regular expressions? Thanks. \$\endgroup\$
    – sergiol
    Commented Nov 23, 2018 at 10:20
5
\$\begingroup\$

PowerShell, 19 bytes

1..100-split'.*2.*'

This script show null-value instead 'numbers with 2 inside' and completely solves the task 'number 2 shouldn’t appear anywhere in the sequence'.

Output:

1


3
4
5
6
7
8
9
10
11


13
14
15
16
17
18
19




















30
31


33
34
35
36
37
38
39
40
41


43
44
45
46
47
48
49
50
51


53
54
55
56
57
58
59
60
61


63
64
65
66
67
68
69
70
71


73
74
75
76
77
78
79
80
81


83
84
85
86
87
88
89
90
91


93
94
95
96
97
98
99
100

PowerShell (output does not contain null-values), 24 bytes

1..100-split'.*2.*'-ne''
\$\endgroup\$
4
\$\begingroup\$

Stax, 6 bytes

Ç░τ╒╜h

Run and debug it

Unpacked, ungolfed, and commented, it looks like this.

AJ  10 squared
f   output each value in [1 .. n] satisfying the following filter
 E  get array of decimal digits in number
 2#     count the number of 2s
 !  logical not

Run this one

\$\endgroup\$
4
\$\begingroup\$

Wolfram Language (Mathematica), 42 bytes

Print@⌈Range[1,100,10/9]~Drop~{18,26}⌉

Try it online!

The arithmetic sequence 1, 19/9, 29/9, 39/9, ... grows at just the right rate that taking the ceiling skips all the numbers ending in 2. Then we get rid of 20 through 29 by Dropping the values at indices 18 through 26.

\$\endgroup\$
5
  • \$\begingroup\$ I don't know if the consensus is that the Print is necessary, but who really cares, anyway. \$\endgroup\$ Commented Oct 3, 2018 at 1:40
  • \$\begingroup\$ [...] but who really cares, anyway. -- that's the spirit ... \$\endgroup\$ Commented Oct 3, 2018 at 1:54
  • \$\begingroup\$ Do \[LeftCeiling] and \[RightCeiling] really count as a single byte :) \$\endgroup\$
    – ktm
    Commented Oct 5, 2018 at 0:41
  • \$\begingroup\$ @user6014 I'm counting them as the 3 bytes they take up in Unicode, but it's still a bit cheaper than an actual Ceiling command. \$\endgroup\$ Commented Oct 5, 2018 at 1:37
  • \$\begingroup\$ @MishaLavrov Sounds fair ! Neat solution. \$\endgroup\$
    – ktm
    Commented Oct 5, 2018 at 1:37
4
\$\begingroup\$

C (GCC), 62 55 Bytes

• 7 Bytes thanks to Jonathan Frech

f(n){for(n=0;++n-101;n/10-2&&n%10-2&&printf("%d,",n));}

Loops from 1 to 100 and prints the number only if 2 is not in the ones or tens place.

Try it online!

\$\endgroup\$
2
  • 1
    \$\begingroup\$ 55 bytes. \$\endgroup\$ Commented Oct 3, 2018 at 2:44
  • \$\begingroup\$ @JonathanFrech thanks that's clever! \$\endgroup\$
    – Asleepace
    Commented Oct 3, 2018 at 2:48
4
\$\begingroup\$

sh + coreutils, 16 chars

seq 100|sed /2/d

Generates sequence from 1 to 100 (inclusive) and deletes any lines that have '2' in them.

\$\endgroup\$
2
  • \$\begingroup\$ This code is identical to answer by Digital Trauma. \$\endgroup\$
    – Ruslan
    Commented Oct 5, 2018 at 21:55
  • \$\begingroup\$ oh crap, didn't see that one, even though I checked. Should I delete this since mine was posted later? \$\endgroup\$
    – 2xsaiko
    Commented Oct 6, 2018 at 7:50
4
\$\begingroup\$

Z80Golf, 49 48 bytes

00000000: 1630 2e0a 5faf f57b fe02 2818 82ff f182  .0.._..{..(.....
00000010: ff92 3cf5 7dff f1bd 280a fe02 2803 f518  ..<.}...(...(...
00000020: e63c 18fa 7b3c bd20 db3e 31ff 3dff ff76  .<..{<. .>1.=..v

Try it online!

Assembly:

ld d, 30h			; ascii '0' character
ld l, 0Ah			; number 10 and ascii newline
tens:
	ld e,a			; store tens digit
	xor a			; reset ones digit to 0
	push af			; store initial ones digit 0
	ones:
		ld a,e		; get stored tens digit
		cp 2
		jr z,cont	; if tens digit==2(e.g.20-29),skip loop
		add d
		rst 38h 	; print tens digit
		pop af		; get stored ones digit
		add d
		rst 38h 	; print ones digit
		sub d
		inc a		; increment ones digit
		push af		; store ones digit
		ld a, l
		rst 38h 	; print newline
		pop af		; get stored ones digit again
		cp l
		jr z,cont	; if ones digit==10, break loop
		cp 2
		jr z,inc_again	; if ones digit==2, incr again
		repeat_loop:
		push af		; store ones digit again
		jr ones		; repeat print loop
		inc_again:
			inc a
			jr repeat_loop
		
	cont:
	ld a,e			; get stored tens digit
	inc a			; increment tens digit
	cp l
	jr nz, tens		; if tens place!=10, continue loop
ld a,31h
rst 38h				; print '1'
dec a
rst 38h				; print '0'
rst 38h				; print '0'
halt

Saved one byte with the repeat_loop jump

\$\endgroup\$
4
\$\begingroup\$

Python 3, 53 51 50 49 46 bytes

['2'in str(n)or print(n)for n in range(1,101)]

Try it online!

Not the strongest language for this task, but I'm new to golfing.

Thanks to the commenters for their tips!

\$\endgroup\$
9
  • \$\begingroup\$ Welcome to PPCG! You can get it down to a round 50 by deleting the space before the if. \$\endgroup\$
    – ElPedro
    Commented Oct 3, 2018 at 18:07
  • \$\begingroup\$ [print(n)for n in range(1,101)if"2"not in str(n)] works. \$\endgroup\$ Commented Oct 4, 2018 at 19:22
  • \$\begingroup\$ Alternatively, based on one of the Python 2 answers: n=17;exec("print((n>177)*10+n//9);n+=10;"*81) \$\endgroup\$ Commented Oct 4, 2018 at 19:24
  • \$\begingroup\$ @JosiahRyanW I wasn't aware of the implicit print, thanks! \$\endgroup\$
    – Gigaflop
    Commented Oct 4, 2018 at 19:29
  • 1
    \$\begingroup\$ '2'in str(n)or print(n) is shorter than a comprehension guard. \$\endgroup\$ Commented Oct 9, 2018 at 3:01
4
\$\begingroup\$

PHP 7.1, 40 bytes

while($i++<100)strstr($i,50)||print$i._;

prints numbers separated by underscores. Run with -nr or try it online.

\$\endgroup\$
2
  • \$\begingroup\$ Nice use of PHP's wacky behavior to separate the numbers, lol \$\endgroup\$ Commented Oct 3, 2018 at 5:19
  • 1
    \$\begingroup\$ The preg_filter() based one is interesting. (I never used that function. 🤫) That one would be shorter with preg_grep(): <?=join(_,preg_grep("/2/",range(1,100),1));. \$\endgroup\$
    – manatwork
    Commented Oct 3, 2018 at 7:50
3
\$\begingroup\$

Kotlin, 32 bytes

{(1..100).filter{'2' !in ""+it}}

Try it online!

\$\endgroup\$
3
\$\begingroup\$

Bash, 31 bytes

printf %d\\n {1..100}|grep -v 2

Try it online!

Thanks to Digital Trauma for short loop.

\$\endgroup\$
6
  • 1
    \$\begingroup\$ Welcome to PPCG! How about echo $i instead of the printf? Or even better printf %d\\n {1..100}|grep -v 2? \$\endgroup\$ Commented Oct 3, 2018 at 3:12
  • \$\begingroup\$ yeah right. i ll update my answer. \$\endgroup\$
    – ketone
    Commented Oct 3, 2018 at 3:14
  • \$\begingroup\$ i am learning actually i don't know that much btw thanks. \$\endgroup\$
    – ketone
    Commented Oct 3, 2018 at 3:16
  • \$\begingroup\$ Just beats my echo {1..100}|tr ' ' \\n|grep -v 2 \$\endgroup\$ Commented Oct 3, 2018 at 8:35
  • \$\begingroup\$ -1 byte if you use sed /2/d instead of grep -v 2. \$\endgroup\$
    – Ruslan
    Commented Oct 5, 2018 at 21:58
3
\$\begingroup\$

ORK, 1092 bytes

There is such a thing as a t
A t can w a number
A t can d a number
A t has a t which is a number

When a t is to w a number:
I have a mathematician called M
M's first operand is the number
M's second operand is 1
M is to add
The number is M's result
My t is 0
I have a number called n
n is the number
I am to d n
M's first operand is my t
M's second operand is 1
M is to compare
I have a scribe called W
If M says it's less then W is to write the number
If M says it's less then W is to write " "
M's first operand is the number
M's second operand is 100
M is to compare
If M says it's less then I am to loop

When a t is to d a number:
I have a mathematician called M
M's first operand is the number
M's second operand is 10
M is to modulo
I have a mathematician called N
N's first operand is M's result
N's second operand is 2
N is to compare
If N says it's equal then my t is 1
M is to divide
The number is M's result
M's first operand is the number
M's second operand is 0
M is to compare
If M says it's greater then I am to loop

When this program starts:
I have a t called T
T is to w 0

Try it online!

Objects R Kool. Output is a space-delimited list of numbers.

This translates (approximately) to the following pseudocode:

class t {
	int t;
	
	void w(number) {
		label T_W;
		mathematician M;
		M.first_operand = number;
		M.second_operand = 1;
		M.add();
		number = M.result;
		t = 0;
		int n = number;
		d(n);
		M.first_operand = t;
		M.second_operand = 1;
		M.compare();
		scribe W;
		if M.its_less { W.write(number); }
		if M.its_less { W.write(" "); }
		M.first_operand = number;
		M.second_operand = 100;
		M.compare();
		if M.its_less { goto T_W; }
	}
	
	void d(number) {
		label T_D;
		mathematician M;
		M.first_operand = number;
		M.second_operand = 10;
		M.modulo();
		mathematician N;
		N.first_operand = M.result;
		N.second_operand = 2;
		N.compare();
		if N.its_equal { t = 1; }
		M.divide();
		number = M.result;
		M.first_operand = number;
		M.second_operand = 0;
		M.compare();
		if M.its_greater { goto T_D; }
	}
}

void main() {
	t T;
	T.w(0);
}

As you can see, everything is done using objects, including basic math and IO functions (through the built-in mathematician and scribe classes). Only whole functions can loop, which explains the need for an object with two functions to do the work.

\$\endgroup\$
3
\$\begingroup\$

MathGolf, 7 6 bytes

♀╒Ç{2╧

Try it online!

Explanation

♀╒       Push 100 and convert to 1-based range ([1,2,...,100])
  Č{     Inverse filter by block
    2╧   Does the number contain 2?
\$\endgroup\$
0
3
\$\begingroup\$

C (clang), 56 bytes

f(i){for(i=0;i++<100;i%10^2&&i/10^2&&printf("%d\n",i));}

Try it online!

\$\endgroup\$
3
\$\begingroup\$

Forth (gforth), 58 57 bytes

: f 'e 1 do i 10 /mod 2 <> swap 2 <> * if i . then loop ;

Try it online!

Explanation

Loops from 1 to 100 (inclusive) and if both the ones and tens place of the index are not equal to 2, print it

Code explanation

: f                    \ start a new word definition
  'e 1 do             \ start a loop from 1 to 100 inclusive
    i 10 /mod          \ get the quotient and remainder of dividing i by 10
    2 <>               \ check if the the tens place is not equal to 2
    swap               \ move the result down the stack one
    2 <>               \ check that the ones place is not equal to 2
    *                  \ multiply results (cheaper AND)
    if i . then        \ if true, output i
  loop                 \ end counted loop
;                      \ end word definition
\$\endgroup\$
2
\$\begingroup\$

Red, 44 bytes

repeat n 100[unless find form n"2"[print n]]

Try it online!

Uses unless instead of if not, because why not? :)

\$\endgroup\$
0
2
\$\begingroup\$

brainfuck, 176 bytes

---------[[-<]-[>]>[>]-[-<]<++]-[>-<+++++++++]>--[>[->]<[<<<]>>[->]>-]<<,<-[-<]>[>]<[.[->+<]++++++++++.,<]>>[>]>>->-<<<<[>>>[<<[<]<.>>[>]>.[-<+>]++++++++++.,>]<<[<]<,<]>>>>.<..

Try it online!

Shorter is definitely possible. This generates the numbers 1,3,4,5,6,7,8,9 and 0,1,3,4,5,6,7,8,9. First it outputs each number in the first list, then it outputs every combination of the first and second list, then finally prints just 100.

Explanation:

---------   Push minus 9
[           Repeat 9 times
  [-<]-[>]    Add the negative of the number to the first list
  >[>]-[-<]<  Add the negative of the number to the second list
  ++          Increment the counter
]
Tape: 255 254 253 252 251 250 249 248 247 0' 0 246 247 248 249 250 251 252 253 254
-[>-<+++++++++]>--  Push 197
Tape: 255 254 253 252 251 250 249 248 247 0 197' 246 247 248 249 250 251 252 253 254
[
  >[->]<    Subtract 197 from every element in both lists to convert to digits
  [<<<]>>
  [->]>-
]
Tape: 58 57 56 55 54 53 52 51 49 0' 49 50 51 52 53 54 55 56 57
<<,<-[-<]>[>]<  Remove the 0 and the 2 from the first list
Tape: 58 57 56 55 54 53 52 51 0 0 0' 49 50 51 52 53 54 55 56 57
[  Loop over the first list
  .[->+<]        Print digit
  ++++++++++.,<  Print a newline
]
>>[>]>>->-   Remove the 2 from the second list
<<<<      
[  Loop over first list
  >>>
  [  Loop over second list
    <<[<]<.        Print first digit
    >>[>]>.        Print second digit
    [-<+>]         Move second digit over one
    ++++++++++.,>  Print a newline
  ]
  <<[<]<,<  Remove the digit from the first list and move to the next
]
>>>>.<..  Print 100 using the second list
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

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