Display numbers lacking 2's

Question

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

Answer 1

SimpleTemplate, 51 bytes

This was a fun challenge! And it is a challenge where my language can do well.

{@forfrom 1to100}{@if_ is notmatches"<2>"}{@echol_}

Cycles through all values from 1 to 100, outputting the ones that don't have 2, separated by a newline.

You can try it on http://sandbox.onlinephpfunctions.com/code/2c97a2b6954c29844f1079938da771d51e2e0d99

Ungolfed:

{@for i from 1 to 100}
    {@if i is not matches "<2>"}
        {@echo i, "\n"}
    {@/}
{@/}

The {@/} is used to close the {@for ...} and {@if ...}, but is optional.
When compiling to PHP, it adds the needed closing.

---

If you're curious, the golfed code results in this PHP code:

// {@forfrom 1to100}
// ~ optimization enabled ~ inlining the results
foreach(array(...) as $DATA['_']){

    // {@if_ is notmatches"<2>"}
    if(!(preg_match("<2>", (isset($DATA['_'])?$DATA['_']:null)))) {

        // {@echol_}
        echo implode('', $FN['array_flat']((isset($DATA['_'])?$DATA['_']:null)));echo PHP_EOL;


// AUTO-CLOSE
};};

Where $FN['array_flat'] is defined outside of this code.

Answer 2

K4, 15 bytes

Solution:

1_&~"2"in'$!101

Example:

q)k)1_&~"2"in'$!101
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

Explanation:

1_&~"2"in'$!101 / the solution
           !101 / range 0..100
          $     / string
    "2"in'      / is "2" in each?
   ~            / not
  &             / indices where true
1_              / drop the first

Extra:

TIO for 16 byte K (oK) answer: Try it online!

Answer 3

Jelly, 7 bytes

³D2eṆƲƇ

Try it online!

Answer 4

Ruby, 35 31 bytes

100.times{|e|p e if/2/!~e.to_s}

Try it online!

Thanks to Conor O'Brien for -4 bytes

Answer 5

Pyth, 17 bytes

VS100I!}\2%"%s"NN

Try it online

My first code golf submission, also my first time using Pyth, this took way longer to put together than I expected.

Explanation

VS100 for loop from 1 to 100

I!}\2%"%s if the string "2" is in the string conversion of N

%"%sN convert N to a string. This is the only way I could figure out how to do this. If there is a shorter way to do int -> string conversion please let me know. I'm honestly just looking for a way to call str() or repr() on it with less chars.

N print n

EDIT: Looks like someone else beat me to it with Pyth. Turns out to convert N to a str I could do `N`, I'm going to leave mine the same because if I change it its almost the exact same solution.

Answer 6

Scala, 56 48 47 45 42 bytes

1 to'd'filter(_+""forall(50!=))map println

Prints the elements separated by a line.

Here is a 38 bytes version that calls toString (technically allowed by the rules):

print(1 to'd'filter(_+""forall(50!=)))

Resulting in:

Vector(1, 3, 4, ..., 100)

Answer 7

Perl 5, 19 bytes

map{/2/||say}1..100

Try it online!

Answer 8

Awk, 32 bytes

END{while(i++<100)print i~2?a:i}

Try it online!

To save space, I used Awk's behavior of assigning the null string to uninitialized variables to avoid initializing the counter and saving a byte with the null string literal.

Answer 9

Uiua, 36 bytes

Returns an array with numbers from 1 to 100 where the elements containing a two are removed.

▽×∩(≠2)⌊⊃÷◿10.+1⇡100

Try It

▽×∩(≠2)⌊⊃÷◿10.+1⇡100
              +1⇡100 # generate numbers 1..100
             . # duplicate the array for filtering
        ⊃÷◿10 # both divide by 10 and mod 10 each number
       ⌊ # floor the division result so that we have the 10s place
  ∩(≠2) # for both the mod and floored division (ones and tens places)
        # check that there is no 2
 × # use multiply as and
▽ # filter the array

Answer 10

JavaScript (ES6), 51 bytes

After reading Arnauld's answer, I wanted to try a non-recursive approach. Sure enough, it's longer, but it may be of some interest.

_=>[...Array(101).keys()].filter(n=>n*!/2/.test(n))

Try it online!

[...Array(101).keys()] creates a list of the numbers 0 through 100. We then filter to get rid of 0 and any number that contains a 2.

Answer 11

Whitespace, 121 bytes

[S S S N
_Push_0][N
S S N
_Create_Label_LOOP][S S S T N
_Push_1][T  S S S _Add][S N
S _Duplicate][S S S T   T   S S T   S T N
_Push_101][T    S S T   _Subtract][N
T   S S N
_If_0_Jump_to_Label_EXIT][S N
S _Duplicate][S S S T   S T S N
_Push_10][T S T T   _Modulo][S S S T    S N
_Push_2][T  S S T   _Subtract][N
T   S N
_If_0_Jump_to_Label_LOOP][S N
S _Duplicate][S S S T   S T S N
_Push_10][T S T S _Integer_divide][S S S T  S N
_Push_2][T  S S T   _Subtract][N
T   S N
_If_0_Jump_to_Label_LOOP][S N
S _Duplicate][T N
S T _Print_integer_to_STDOUT][S S S T   S T S N
_Push_10][T N
S S _Print_character_to_STDOUT][N
S N
N
_Jump_to_Label_LOOP]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.

Try it online (with raw spaces, tabs and new-lines only).

Pseudo-code:

Integer i = 0
Label LOOP:
  i = i+1
  If(i == 101):
    Exit program
  If(i modulo-10 == 2):
    Go to next iteration of LOOP
  If(i integer-divided by 10 == 2):
    Go to next iteration of LOOP
  Print i to STDOUT
  Print a newline to STDOUT
  Go to next iteration of LOOP

Answer 12

Gol><>, 19 bytes

`dFLP:aSD2=$2=+ZN|;

Try it online!

Explanation:

`dFLP:aSD2=$2=+ZN|;

`d                  //Push 100 to the stack
  F                 //For loop from 0 to 99
   LP               //  Push the loopcounter+1 to the stack,achieving a range [1..100]
     :              //  Double for potential output later (saves 1 byte compared to pushing it again)
      aSD           //  Push division & modulus of current number by 10
         2=         //  Check if (num % 10) == 2 , pushes either 0 or 1
           $2=      //  Check if (num / 10) == 2 , "
              +     //  Add the results acting as a logical or for is zero question
               ZN   //  If neither the mod nor the div are equal to 2 output the number
                 |; //Exit after loop

Answer 13

Ruby, 28 characters

puts [*?1..'100'].grep_v /2/

Thanks to:

• G B, as I borrowed the idea of not using a proc from his deleted answer

Sample run:

bash-4.4$ ruby -e 'puts [*?1.."100"].grep_v /2/' | head -15
1
3
4
5
6
7
8
9
10
11
13
14
15
16
17

Try it online!

Answer 14

MBASIC, 59 bytes

1 FOR I=1 TO 100:IF INSTR(STR$(I),"2")=0 THEN PRINT I
2 NEXT

There's probably a mathematical way to do this, but this approach is what first came to mind.

Answer 15

T-SQL, 65 bytes

DECLARE @ INT=1a:IF @ NOT LIKE'%2%'PRINT @;SET @+=1IF @<101GOTO a

I'm a bit annoyed that this variable loop is shorter than the best set-based SQL variant I could find (91 bytes):

SELECT DISTINCT number FROM spt_values WHERE number>0and number<101AND number NOT LIKE'%2%'

This one even has the additional restriction of needing to be run in the master database (since it uses an undocumented system table).

The best set-based solution I could find without that requirement was 94 bytes:

WITH t AS(SELECT 1n UNION ALL SELECT n+1FROM t WHERE n<100)SELECT*FROM t WHERE n NOT LIKE'%2%'

Answer 16

Perl 5 (5.12+), 25 bytes

$,=$/;say grep!/2/,1..100

Try it online!

Pretty straightforward. The $,=$/ makes the following print put a newline between list elements, which is shorter than using join.

Answer 17

Attache, 24 bytes

Output!2&`!in@List\1:100

Try it online!

Alternatively, Print=>2&`!in@List\1:100.

Filters (\) from 1:100 values whose digits (@List) do not contain (`!in) a 2 (2&), which is then Outputted.

Answer 18

Ruby, 31 bytes

p$.if"#{$.+=1}"!~/2/ until$.>99

Try it online!

A different, iterative approach than other ruby answers. This uses the not-match operator !~ as well as the implicitly-zero input line number variable $. as the iterator. The TIO link shows my golfing progress, from 48 bytes to 31 bytes.

Answer 19

APL(NARS), 17 chars, 34 bytes

a/⍨∼'2'∊¨⍕¨a←⍳100

test

  a/⍨∼'2'∊¨⍕¨a←⍳100
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

Answer 20

F#, 66 bytes

Solution

Seq.filter(fun i->i%10<>2&&i/10<>2){1..100}|>Seq.iter(printfn"%d")

Explanation

Filters a sequence of numbers 1 to 100 by retaining those whose modulus of 10 is not 2, and which integer-divided by 10 do not result in 2, then prints the sequence with newlines between items.

This works for numbers up to and including 199. A more general solution is slightly longer (74 bytes):

Seq.filter(fun i->(string i).IndexOf '2'<0){1..100}|>Seq.iter(printfn"%d")

With proper spacing, and rearranged for readability, this looks as follows:

{1 .. 100}
|> Seq.filter (fun i -> (string i).IndexOf '2' < 0)
|> Seq.iter (printfn "%d")

Answer 21

V, 14 13 bytes

Saved 1 byte thanks to @oktupol

á199ñÄj<C-a>ñç2/d

Try it online! <C-A> represents the start of heading character (0x01)

Explanation

á1            Insert a 1 on the first line
99ñ           Repeat 99 times:
 Ä             Duplicate the last line
 j<C-A>        Increment the last line by one
ñç2/          For every line containing a 2:
 d             Remove the line

Answer 22

Rust, 65 bytes

fn main(){for i in 1..101{if i%10!=2&&i/10!=2{println!("{}",i)}}}

Try it online!

Similar to the answers by Meerkat and dumetrulo, just iterate through and print only those whose ones digit and tens digit are not 2.

Answer 23

Ohm v2, 7 9 bytes

⁸#u⁇2εX

Explanation:

⁸#u⁇2εX
⁸        Push 100
 #       Push range 0..a
  u      Turn to string (vectorizes)
   ⁇     Filter only those that match conditional
    2εX  Match those that do not contain "2"

Try it online!

Answer 24

LUA, 113 68 47 45 bytes

Thanks to LUA's rather loose dynamic typing, can straight-up search the integer.

Thanks to @manatwork (twice)

Thanks to @Jo King

for x=1,100 do n=("").find(x,2)or print(x)end

Try it online!

Answer 25

[C# (.NET Core)], 63 62 bytes

Thanks to milk for saving one byte in the for loop.

for(int i=0;++i<101;)if(i%10!=2&&i/10!=2)Console.WriteLine(i);

Try it online!

Ungolfed:

for (int i = 0; ++i < 101;)         // all integers from 1-100 (starts from zero, increments before code runs)
    if (i % 10 != 2                 // all numbers not ending with '2'
                    && i / 10 != 2) // all numbers not starting with '2'
        Console.WriteLine(i);       // write to console

Answer 26

Crystal, 65 bytes

(1..100).each do |x|
    x.to_s().includes?('2') ? 0 : puts x
end

Try it online!

Answer 27

Tidy, 27 bytes

{{x:"2"!in x.0}from[1,100]}

Try it online!

Function which returns the appropriate range. x.0 concatenates x and 0 as a string.

Answer 28

Haskell, 57 Bytes

Solution

import Data.List
unlines.nub.map(filter(/='2').show).$[1..100]

or

import Data.List
nub.map(filter(/='2').show)$[1..100]

if you just want the list.

Output

Prelude Data.List> unlines.nub.map(filter(/='2').show)$[1..]
"1\n\n3\n4\n5\n6\n7\n8\n9\n10\n11\n13\n14\n15\n16\n17\n18\n19\n0\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

Explanation

Makes all numbers a string, removes their '2's and weeds out the duplicates.

Answer 29

Ruby, 33 bytes

Solution:

puts (?1..'100').reject{|x|x[?2]}

Answer 30

JavaScript (Node.js), 45 44 bytes

-1 byte thanks to Neil

for(i=0;i++<100;)/2/.test(i)||console.log(i)

Try it online!