text:
Letters challenge
Using the word “conemon” print each character 2 times more than the last. The first letter, “c”, should be printed 10 times, the second 12 and so on. Each repeated-letter-string should be printed on a new line.
So the end-result becomes:
cccccccccc
oooooooooooo
nnnnnnnnnnnnnn
eeeeeeeeeeeeeeee
mmmmmmmmmmmmmmmmmm
oooooooooooooooooooo
nnnnnnnnnnnnnnnnnnnnnn

Cccccccccc
Oooooooooooo
Nnnnnnnnnnnnnn
And so on the solution should be displaced like that. There should be new line after every character is printed n times

Welcome to PPCG! I have update the challenge text to reflect your comment above (specifications should be in the post not in the comments). I also fixed up the grammar a little. Feel free to edit it more.

The less characters the better.

What is the smallest number of characters that could be used to solve this problem using python?

Don't know if this is of use for anyone, but conemon is rot10(seduced).

Are white spaces allowed before or after a string?

Is it acceptable to return the list of lines, or do we need to output as a string?

Can we output it capitalised i.e. CONEMON

Is it allow the follow output: ccccccccccoooooooooooonnnnnnnnnnnnnneeeeeeeeeeeeeeeemmmmmmmmmmmmmmmmmmoooooooooooooooooooonnnnnnnnnnnnnnnnnnnnnn
?

@RosLuP The spec is clear; it's not allowed.

Python 2, 36 bytes
i=8
for c in'conemon':i+=2;print c*i

Try it online!

cccccccccc
oooooooooooo
nnnnnnnnnnnnnn
And so on
the solution should be displayed like above

@Monolica Fixed

who would be able to improve this python code to a shorter code.                   i=8
for c in'conemon':i+=2;print c*i

@Monolica FYI standard practice on PPCG is to wait quite some time (e.g. 1 week) before accepting an answer. Furthermore, for code-golf many question-posers don't ever actually accept any answer. If you are going to accept an answer, however, it should be the shortest code in bytes, since that is the winning criteria given by code-golf (given two of the same length it would be usual to accept the first to reach such a byte-count).

R, 50 47 45 bytes
This is some serious R abuse. I create a quote R expression C(O,N,E,M,O,N) and feed it into the string repeat function strrep, which kindly coerces each name inside the quote into a string. Shorter than scan !
write(strrep(quote(C(O,N,E,M,O,N)),5:11*2),1)

Try it online!

That deserves its own tip.

K (ngn/k), 20 19 bytes
(2*5+!7)#'"conemon"

Try it online!

05AB1E, 16 14 bytes
.•Ω‡h₅•Sā·8+×»

-2 bytes thanks to @Emigna.
Try it online.
Explanation:
.•Ω‡h₅•           # Push "conemon"
       S          # Convert it to a list of character: ["c","o","n","e","m","o","n"]
        ā         # Push a list in the range [1, length]: [1,2,3,4,5,6,7]
         ·        # Double each: [2,4,6,8,10,12,14]
          8+      # Add 8: [10,12,14,16,18,20,22]
            ×     # Repeat the characters that many times
             »    # Join the list by newlines (and output implicitly)

See this 05AB1E tip of mine (section How to compress strings not part of the dictionary?) to understand why .•Ω‡h₅• is "conemon".

.•Ω‡h₅•Sā·8+×» for 14.

@Emigna I was just looking for a way to remove that map. Smart way with ā·, thanks!

MathGolf, 15 bytes
╕│Pùmon+ô8î∞+*p

Try it online!
Explanation
╕│P                 Compression of 'cone'
   ùmon             Push 'mon'
       +            Concatenate together
        ô          Foreach over each letter
         8         Push 8
          î∞       Push the index of the loop (1 based) and double it
            +      Add the 8
             *p    Repeat the letter that many times and print with a newline

I'll write an explanation of the string compression in the mathgolf chat, look there in a minute. You could get 2-3 bytes off this solution.

This is one byte shorter.

The mapping to list of chars should not be needed now, saving one byte

Java 11, 78 bytes
v->{int i=8;for(var c:"conemon".split(""))System.out.println(c.repeat(i+=2));}

Try it online. (NOTE: String.repeat(int) is emulated as repeat(String,int) for the same byte-count, because Java 11 isn't on TIO yet.)
Explanation:
v->{                     // Method with empty unused parameter and no return-type
  int i=8;               //  Integer `i`, starting at 8
  for(var c:"conemon".split(""))
                         //  Loop over the characters (as Strings) of "codemon"
    System.out.println(  //   Print with trailing new-line:
      c.repeat(          //    The current character repeated
        i+=2));}         //    `i` amount of times, after we've first increased `i` by 2

Javascript, 55 52 bytes
saved 3 bytes thanks to @Arnauld
s=>[...'conemon'].map(x=>x.repeat(i+=2),i=8).join`
`

f=s=>[...'conemon'].map(x=>x.repeat(i+=2),i=8).join`
`
console.log(f());

This is a kolmogorov-complexity challenge which doesn't take any input, so you'll have to hardcode 'conemon' within the code. On the good news side, you don't need to include f= in your byte count, unless the function is referring to itself -- which is not the case here.

Hi. Welcome to PPCG. Quick note, you dont need to count f= bytes unless you use recursion so you answer is actually 47 bytes length

Thank's for the clarification! I updated my answer.

Japt -R, 13 bytes
`¬¶n`¬Ë²p5+E

Try it

Explanation
`¬¶n`¬Ë²p5+E
`¬¶n`            :Compressed string "conemon"
     ¬           :Split
      Ë          :Map each character at 0-based index E
       ²         :  Repeat twice
        p5+E     :  Repeat 5+E times
                 :Implicitly join with new lines and output

PowerShell, 35 34 bytes
'conemon'|% t*y|%{"$_$_"*(++$j+4)}

Try it online!
-1 byte thanks to mazzy
Literal string 'conemon' is converted toCharArray, then for each character we multiply it out by the appropriate length. This is handled by doubling up the character $_$_ then multiplying by $j+4 with $j pre-incremented each time (i.e., so it'll start at 1+4 = 5, which gets us 10 characters).
Each newly formed string is left on the pipeline, and implicit Write-Output gives us newlines for free.

-1? 'conemon'|% t*y|%{"$_$_"*(++$j+4)}. It is not reentrant. It requires rv j before second run.

@mazzy Or save it into a .ps1 script and execute the script. Thanks for the byte!

Tcl, 78 bytes
set i 8
lmap x {c o n e m o n} {set s ""
time {set s $s$x} [incr i 2]
puts $s}

Try it online!

K (oK), 29 bytes
{i::8;{i+::2;i#x}'x}"conemon"

Try it online!
I'm not the biggest fan of this solution as it's bad practice (global variables), but it's short. May work on a better solution.

You'll need to include the "conemon" in your bytecount - take a look at the other K solution for inspiration :)

The other K solution is very neat, still coming to grips with this language. Do you know of any resources for k? I work with q, but would like to become more familiar with what's under the hood

Q is just syntactic sugar on top of K4, and you can see the underlying K commands by typing the Q command raw into the REPL, e.g. count will return #:. There is a good manual for oK available here (an open source implementation of a mix of K5 and K6) which explains a lot of the commands. I would also suggest you taking a look at all the codegolf answers written in K for inspiration.

There's also a Q Idioms page which shows how to perform the same task in Q or K

Great, thank you for the link
<<<Q is just syntactic sugar on top of K4, and you can see the underlying K commands by typing the Q command raw into the REPL>>>
That's literally how I've been writing any of these K answers, writing it in q and then just switching to the underlying K if I can because it's so much more terse
Thanks for the link

Husk, 11 bytes
zR↓4İ0¨cΦ◄‰

Try it online!
Explanation
zR↓4İ0¨cΦ◄‰
      ¨cΦ◄‰        A = The compressed string "conemon"
    İ0             B = The infinite list of even positive numbers
  ↓4                             without its first four elements: [10,12,14,16...]
zR                 Create a list of strings replicating each character in A as many times
                   as the corresponding number in B

A list of strings in Husk is printed by joining them with newlines.

Perl 6, 36 34 bytes
-2 bytes thanks to nwellnhof
("conemon".comb Zx(5..*X*2))>>.say

Try it online!
Explanation:
 "conemon".comb                     # Get conemon as a list of characters
                   5..*             # A lazy list from 5 to infinity
                       X*2          # Multiplied by 2
                                    # This results in the list 10,12,14 etc.
                Zx                  # Zip the two together with the string multiplication operator
                                    # This multiplies each character by 10, 12 etc.
                            >>.say  # Print each line

Would you be able to explain your solution?

@Monolica I've added an explanation

Jelly,  14  13 bytes
-1 Thanks to Erik the Outgolfer (pointing me to the real optimal string compressor)
...and, of course, to user202729 (for creating it)!
“¦[Þ⁷ƥ»J+4×ḤY

A full program which prints the output required.
Try it online!
How?
“¦[Þ⁷ƥ»J+4×ḤY - Main Link: no arguments
“¦[Þ⁷ƥ»       - compressed string as a list of characters -> ['c','o','n','e','m','o','n']
              - (...due to this being a leading constant this is now the argument too)
       J      - range of length  -> [ 1, 2, 3, 4, 5, 6, 7]
         4    - literal four
        +     - add (vectorises) -> [ 5, 6, 7, 8, 9,10,11]
          ×   - multiply by the argument -> ['ccccc','oooooo',...,'nnnnnnnnnnn']
           Ḥ  - multiply by 2 (vectorises) -> ['cccccccccc','oooooooooooo',...,'nnnnnnnnnnnnnnnnnnnnnn']
            Y - join with newline characters
              - implicit print

I guess there's no literal for 11 in Jelly?

There is 11 :)

¢nṣkœ+ → ¦s⁾ıß. Yes, mon is a word.

Red, 53 bytes
n: 8 foreach c"conemon"[loop n: n + 2[prin c]print""]

Try it online!

J, 25 24 bytes
 echo'conemon'#"0~2*5+i.7

Try it online!
Note: There are trailing spaces on all lines except the last one.

Charcoal, 14 bytes
Ｅconemon×ι⁺χ⊗κ

Try it online! Link is to verbose version of code. Explanation:
 conemon        Literal string
Ｅ               Map over characters
             κ  Current index
            ⊗   Doubled
           χ    Predefined variable 10
          ⁺     Add
         ι      Current character
        ×       Repeat
                Implicitly print each string on separate lines

APL (Dyalog Classic), 21 bytes
⎕←↑'conemon'⍴¨⍨8+2×⍳7

Try it online!

I believe you can drop the first 2 bytes

@Quintec Doesn't print anything in TIO without the first 2 bytes, that's why I left them

put it in input

@Quintec - I'm not sure if it's acceptable.

Actually, for TIO you need to put anything prefixed with ⎕← to display output, or put it in input. For TryAPL and Dyalog application you don't.

Japt, 17 bytes
"conemon"¬Ëp°EÑ+8

Try it online!

Japt, 14 bytes
`¬¶n`¬Ëp°EÑ+8

Try it online!

Explanation
"conemon"¬Ëp°EÑ+8           Full Program
"conemon"¬                  Split each letter
          Ëp                Map and repeat
            °EÑ+8           ((1 + Index) * 2) + 8

Looks like you beat me to it. You're welcome to this if you want it.

@Shaggy Nah, keep yours, It is better than mine jejeje. Btw, why the string compression worked for you? I used v2.0

Compressing it as a single string and trying to decompress it with backticks didn't work for me either but it did with O.d() - it happens sometimes. I ended up splitting it into co and nemon, compressing those strings individually and then recombining them.

I tweaked mine slightly to be a little less similar to yours.

Haskell, 44 bytes
i=[0..]
g=["conemon"!!n<$take(10+n*2)i|n<-i]

Try it online!
We generate a list of lists of lengths 10, 12 etc. (by taking the appropriate amount of elements from an infinite list) and then replace each element in each such list with corresponding character from the required string.

["conemon"!!n<$[0..9+2*n]|n<-[0..]] (without i). As anonymous functions are allowed, you don't have to give the function a name, so drop the g=. However, I'm not sure whether a list of strings is a valid output format for this particular challenge as it says "each [...] string [...] printed on a new line".

Perl 5, 33 bytes
conemon=~s/./say$&x(8+2*++$i)/reg

Try it online!
Explanation
         s/ /                /     # Replace
                                g  # each
           .                       # character
       =~                          # in
conemon                            # string "conemon"
                              r    # non-destructively (source is read-only)
                               e   # only for the side effect of
             say                   # printing with newline
                $&                 # the full match (character)
                  x                # repeated
                        ++$i       # 1,2,3,...
                      2*           # 2,4,6,...
                    8+             # 10,12,14,...
                   (        )      # times

Can you explain your solution please?

@Monolica Done.

Canvas, 14 bytes
conemon｛²«８＋×］

Try it here!

SOGL V0.12, 13 bytes
╝⌠Ei№‘{ē«L+*P

Try it Here!
Explanation:
╝⌠Ei№‘       push "conemon" - 2 words "cone" and "mon" compressed
      {      for each
       ē       push the value of e (default 0), and increment it (aka e++)
        «      multiply that by 2
         L+    add 10 to that
           *   repeat the character that many times
            P  and print it

F#, 71 bytes
let d=Seq.iteri(fun i c->System.String(c,10+i*2)|>printfn"%s")"conemon"

Try it online!
Seq.iteri iterates through the sequence and applies the function to the index of the item i and the item itself c. In this case the string, every character in the string conemon.
System.String is a shortform of new System.String, taking the current letter c and repeating it 10+i*2 times, where i is the index of the letter. It then prints the string to the output with a new line.
You can omit the string and shorten it to:
let d=Seq.iteri(fun i c->System.String(c,10+i*2)|>printfn"%s")

And this will work with every string. But given this challenge is specifically for conemon the string is hard-coded.

C# (Visual C# Interactive Compiler) 65 64 bytes
for(int i=0;i<7;){WriteLine(new string("conemon"[i],i++*2+10));}

Try it online!
thanks to @Jonathan Frech saving 1 byte
new string(char, int) repeats the char as often as the int value.
C#, 72 bytes without "Console" as static using (example outside interactive compiler):
for(int i=0;i<7;){Console.WriteLine(new string("conemon"[i],i++*2+10));}

I think you can move your i++ into your i*2+10.

Pyth, 17 16 bytes
V"conemon"*N~+T2

Try it online here.
V"conemon"*N~+T2   Implicit: T=10
V"conemon"         For each character in "conemon", as N:
          *N  T      Repeat N T times, implicit print with newline
            ~+T2     T += 2

PowerShell, 46 bytes
$i=8;'c','o','n','e','m','o','n'|%{$_*($i+=2)}

# $i=8;foreach($c in [char[]]'conemon'){[string]$c*($i+=2)}

Welcome to PPCG again! https://codegolf.stackexchange.com/questions/191/tips-for-golfing-in-powershell

jq, 56 characters
(52 characters code + 4 characters command line options)
[[range(5;12)],"conemon"/""]|transpose[]|.[1]*.[0]*2

Sample run:
bash-4.4$ jq -nr '[[range(5;12)],"conemon"/""]|transpose[]|.[1]*.[0]*2'
cccccccccc
oooooooooooo
nnnnnnnnnnnnnn
eeeeeeeeeeeeeeee
mmmmmmmmmmmmmmmmmm
oooooooooooooooooooo
nnnnnnnnnnnnnnnnnnnnnn

Try it online!

Ruby, 48 bytes
->{a=4;'conemon'.each_char{|s|puts s*(a=1+a)*2}}

Try it online!

Pyth, 17 bytes
j.e*b+Tyk"conemon

Try it here
Explanation
j.e*b+Tyk"conemon
 .e      "conemon    For each character 'b' and index 'k' in "conemon"...
   *b+Tyk            ... get 2k + 10 copies of b.
j                    Join the result with newlines.

MBASIC, 80 73 bytes
1 S$="conemon":FOR I=1 TO LEN(S$):PRINT STRING$(8+I*2,MID$(S$,I,1)):NEXT

Saved a loop by using the STRING$ function to generate the string of characters.
Saved another 7 bytes by computing the length relative to the loop index.
Output:
cccccccccc
oooooooooooo
nnnnnnnnnnnnnn
eeeeeeeeeeeeeeee
mmmmmmmmmmmmmmmmmm
oooooooooooooooooooo
nnnnnnnnnnnnnnnnnnnnnn

D, 48 bytes
foreach(i,c;"conemon")c.repeat(10+i*2).writeln;

Explanation:
foreach(i,c;"conemon")                           // Loop over string with index i, char c
                      c.repeat(10+i*2)           // Repeat character 10 + (i*2) times
                                      .writeln;  // Write with newline

Run with rdmd:
$ rdmd --eval='foreach(i,c;"conemon")c.repeat(10+i*2).writeln;'
cccccccccc
oooooooooooo
nnnnnnnnnnnnnn
eeeeeeeeeeeeeeee
mmmmmmmmmmmmmmmmmm
oooooooooooooooooooo
nnnnnnnnnnnnnnnnnnnnnn

V, 27 26 bytes
Iµc
¶o
·n
¸e
¹m
±o
±±n<esc>Îä$

<esc> represents the escape character (ascii 27)
Try it online!
Explanation
I                Enter insert mode
µc                Write 5 c and a newline
¶o                Write 6 o and a newline
·n                Write 7 n and a newline
¸e                Write 8 e and a newline
¹m                Write 9 m and a newline
±o                Write 10 o and a newline
±±n               Write 11 n
<esc>            End insert mode
Îä$              Duplicate every line

T-SQL, 84 bytes
DECLARE @ INT=1a:PRINT REPLICATE(SUBSTRING('conemon',@,1),2*@+8)SET @+=1IF @<8GOTO a

The variable/loop approach turned out shorter than the best set-based variation I came up with (91 bytes):
SELECT REPLICATE(SUBSTRING('conemon',n,1),2*n+8)FROM(VALUES(1),(2),(3),(4),(5),(6),(7))a(n)

I don't know what it is, but I found this question particularly annoying. Which probably means it's a good question.

Z80Golf, 35 31 bytes
00000000: 2118 0016 0a42 7efe 0028 0cff 10f8 3e0a  !....B~..(....>.
00000010: ff23 1414 4218 ef76 636f 6e65 6d6f 6e    .#..B..vconemon

Try it online!
Assembly:
ld hl,str
ld d, 10
ld b, d
loop:
	ld a,(hl)
	cp 0
	jr z, hlt
	rst 38h; putchar
	djnz loop
ld a, 10; newline
rst 38h
inc hl
inc d
inc d
ld b, d
jr loop
hlt:
	halt
str:
	db 'conemon'

-4 bytes changed call 8000h to rst 38h

Stax, 12 bytes
ü¡│\½◙S·«═▓╞

Run and debug it
Unpacked, ungolfed, and commented, it looks like this.
`Mwys-` compressed literal "conemon"
m       for each character output the result after running the rest of the program
 ]      wrap in singleton array
 iHA+   `2 * i + 10` where i is the 0-based iteration index
 *      repeat array

Run this one

APL(NARS), 19 chars, 38 bytes
⊃'conemon'/¨⍨2×4+⍳7

test:
  ⊃'conemon'/¨⍨2×4+⍳7
cccccccccc
oooooooooooo
nnnnnnnnnnnnnn
eeeeeeeeeeeeeeee
mmmmmmmmmmmmmmmmmm
oooooooooooooooooooo
nnnnnnnnnnnnnnnnnnnnnn

[PHP], 76 bytes
$i=8;foreach(str_split("conemon") as $k){$i+=2;echo str_repeat($k,$i)."\n";}

Try it online

Z80Golf, 23 bytes
00000000: 0907 060d 0507 0676 1a3c 473c 127e ee68  .......v.<G<.~.h
00000010: ff10 fd3e 0a23 e5                        ...>.#.

Try it online!
Disassembly
start:
  add hl, bc ; db ('c'^$68)-2
  rlca       ; db 'o'^$68
  ld b, $0d  ; db 'n'^$68
             ; db 'e'^$68
  dec b      ; db 'm'^$68
  rlca       ; db 'o'^$68
  ld b, $76  ; db 'n'^$68
             ; halt

  ld a, (de) ; manipulate the byte at address 0
  inc a
  ld b, a    ; loop count
  inc a
  ld (de), a ; save +2 of previous

  ld a, (hl)
  xor $68    ; the char to print
loop:
  rst $38    ; print it `b` times
  djnz loop

  ld a, $0a  ; newline to print
  inc hl     ; string index & return address
  push hl

The Hello World trick strikes again.  The first byte is also used to track the loop count.

GolfScript, 26 bytes
7:a;"conemon"{{.}a)):a*n}%

Try it online!
I'm surprised nobody else has done a solution in this language by now. However, I won't be surprised when this submission is eventually beaten.

JavaScript (Node.js), 56 bytes
[..."conemon"].map((e,i)=>console.log(e.repeat(i*2+10)))

Try it online!

///, 74 bytes
/E/eeee//M/mmm//N/nnnn//O/oooo//;/OOO
NNNnn/cccccccccc
;
EEEE
MMMMMM
OO;NN

Try it online!

Retina, 29 bytes
K`conemon
L$`.
$.(5*_$`)*2*$&

Try it online! Explanation:
K`conemon

Initialise the buffer with the text.
L$`.

Loop over each character and output each substituion on its own line.
$.(5*_$`)*2*$&

Repeat the match (5 + index) * 2 times.

LUA, 67 66 bytes
s="conemon"
l=10
for i in s:gmatch'.'do print(i.rep(i,l))l=l+2 end

Try it online.

Deadfish~, 129 bytes
{{i}}d{c}{{d}i}ic{{i}}i{c}cc{{d}}dc{{i}}{c}cccc{{d}}c{{i}d}i{c}cccccc{{d}i}dc{{i}}d{c}cccccccc{{d}}ic{{i}}i{cc}{{d}}dc{{i}}{cc}cc

Try it online!


text:
Backhanded Compliments
This challenge is created in celebration of my first esoteric language, Backhand!
Backhand is a one dimensional language with a non-linear pointer flow. The pointer moves three steps at a time, only executing every third instruction.
The program 1..1..+..O..@ will add 1+1 and output 2 before terminating. The intermediate instructions are skipped, so 1<>1()+{}O[]@ is exactly the same program.
When the pointer is about to step off the end of the tape, it instead reverses direction and steps the other way, so 1.@1.O+. is the same program. Note that it only counts the end instruction once. This allows us to compress most linear programs down, such as 1O+1@
Your challenge here is to write a program or function that take a string, and output the instructions that would be executed if the program was interpreted like Backhand (you don't need to handle any actual Backhand instructions). You are to only output until the pointer lands on the last character of the string (at which point the execution would normally go backwards).
But wait, that's not all! When your program itself is interpreted in this fashion, the resulting code should output one of the below:

(Mostly) works
Turing complete
'Recreational'  (quotes can be either ' or ", but not both)
Perfectly okay
Only a few bugs

For example, if your source code is code 2 backhand, then the program ce cankb od2ahd should output one of these phrases.
Test cases:
"1  1  +  O  @"  -> "11+O@"
"1O+1@"          -> "11+O@"
"HoreWll dlo!"   -> "Hello World!"
"abcdefghijklmnopqrstuvwxyz" -> "adgjmpsvyxurolifcbehknqtwz"
"0123456789"     -> "0369"  (not "0369630369")
"@"              -> "@"
"io"             -> "io"  (Cat program in Backhand)
"!?O"            -> "!?O" (Outputs random bits forever in Backhand)
"---!---!"       -> "-!-----!"

And a reference program written in, of course, Backhand (this might be a bit buggy Okay, I think I've fixed it).
Rules.

Standard Loopholes are forbidden
The input of the first program will contain only printable ASCII and newlines (that is, bytes 0x20-0x7E as well as 0x0A)
You can choose whether your second program is converted from your first by bytes or by UTF-8 characters.
Second program:

Case does not matter, so your output could be pErFectLy OKay if you want.
Any amount of trailing/leading whitespace (newline, tabs, spaces) are also okay.
The second program should be the same language as the first, though not necessarily the same format (program/function)
I'm happy to include suggestions from the comments on extra phrases (as long as they're not too short)

As this is code-golf, your aim is to get the shortest answer for your language!
In two weeks, I'll award a 200 bounty to the shortest Backhand answer.

Sandbox (deleted)

Suggested testcase: "---!---!" (or any string where the last character appears more than once)

When your program itself is interpreted in this fashion - interpreted by what?

@ngm If your complete program is input in itself (or the reference Backhand program linked below the test cases), it should result in a program that outputs one of those strings.

So let's say I write an R program (because that's pretty much all I do around here.) My R program has to transform the Backhanded code into the sequence of Backhanded instructions. In addition, my R program when input into into itself has to become another R program that outputs on of those strings when run (in the case of R, interpreted by an R interpreter). Is this correct?

@ngm Yes. -----

The first Backhand snippet doesn’t render correctly at least on Safari, you might need some HTML magic to get it to put two spaces between the instructions. Note the actual test case code block works fine.

@boboquack I've changed out the spaces for .s

Python 2, 163 130 127 121 115 99 96 bytes
i=input() ###
print(i+i[-2:0:-1]+i)[:len(i)*(len(i)%3%2or 3):3]

#'p lr+yi  n'ottk(ca'eyPf'er)

Try it online!
Outputs:
int #rt+-01i:n)l(%2 :
print('Perfect' + # 33o3ie*(l)]:2i(i
#(p=iu)#pni[:-+[ei(n)%r)]
'ly okay')

R, 187 bytes
 # c  a  t  (  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  )  #
g=function(x,n=nchar(x),i=c(1:n,(n-1):1,2:n),j=seq(1,3*n-2,3),k=i[j][1:which(i[j]==n)[1]])cat(substring(x,k,k),sep='')

Try it online!
The single space at the end is needed so that the \n never gets printed when the program is applied to itself.
Explanation
Part 1:
Ungolfed:
 # c  a  t  (  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  )  #
g <- function(x) {
  n <- nchar(x)                      # number of characters in string
  i <- c(1:n, (n - 1):1, 2:n)        # index: 1 to n, n-1 back to 1, 2 to n
  j <- seq(1, 3 * n - 2, 3)          # every third element of i
  k <- i[j][1:which(i[j] == n)[1]]   # the elements of i at indices j, up to the first appearance of n
  cat(substring(x, k, k), sep = "")  # extract from x the characters at indices k, and paste them together
}

Part 2:
The function produces this when it acts on the entire program:
cat('Perfectly okay')#=ni(ncr)=1,-:2)=q,n,,i]:i(j=[]assi(k)e'

05AB1E, 43 40 38 37 bytes
-2 bytes (40→38) thanks to @Emigna.
„€€Ã€„Ð€€µ'€Ý)\[ûDN3*©è  ?®IgD#<ÖNĀ*#

Try it online. (PS: Switch the language from 05AB1E (legacy) to 05AB1E for test case 0123456789. The legacy version is faster, but it shows incorrect results for number inputs with leading zeros.)
The 'backhanded' program will become:
„ÃÐµÝ[N© I#N#

Which will output perfectly okay in full lowercase.
Try it online.
Explanation base program:
„€€Ã€           # Push the string "the pointed"
„Ð€€µ           # Push the string "dm one"
'€Ý            '# Push the string "been"
     )          # Wrap the entire stack in a list
      \         # And remove that list from the stack again
[               # Start an infinite loop
 û              #  Palindromize the string at the top of the stack
                #   i.e. "1O+1@" becomes "1O+1@1+O1" the first iteration,
                #        and "1O+1@1+O1O+1@1+O1" the next iteration, etc.
  D             #  Duplicate the palindromized string
 N3*            #  0-indexed index of the loop multiplied by 3
    ©           #  Save it in the register (without popping)
     è?         #  Index into the string and print the character
  Ig            #  If the length of the input is exactly 1:
     #          #   Stop the infinite loop
 ®  D <Ö        #  If the value from the register is divisible by the length - 1
          *     #  And
        NĀ      #  The 0-indexed index of the loop is NOT 0:
           #    #   Stop the infinite loop

Explanation 'backhanded' program:
„ÃÐµÝ           # Push the string "perfectly okay"
     [          # Start an infinite loop
      N©        #  Push the index, and store it in the register (without popping)
          I     #  Push the input (none given, so nothing happens)
           #    #  If the top of the stack is 1, stop the infinite loop
            N   #  Push the index again
             #  #  If the top of the stack is 1, stop the infinite loop

Step by step the following happens:

„ÃÐµÝ: STACK becomes ["perfectly okay"]
[: Start infinite loop
(first loop iteration) N©: STACK becomes ["perfectly okay", 0]
(first loop iteration) I: STACK remains ["perfectly okay", 0] because there is no input
(first loop iteration) #: STACK becomes ["perfectly okay"], and the loop continues
(first loop iteration) N: STACK becomes ["perfectly okay", 0]
(first loop iteration) #: STACK becomes ["perfectly okay"], and the loop continues
(second loop iteration) N©: STACK becomes ["perfectly okay", 1]
(second loop iteration) I: STACK remains ["perfectly okay", 1] because there is no input
(second loop iteration) #: STACK becomes ["perfectly okay"], and the loop breaks because of the 1 (truthy)
Implicitly prints the top of the stack to STDOUT: perfectly okay

See the steps here with the debugger on TIO enabled.
See this 05AB1E tip of mine (section How to use the dictionary?) to understand why „€€Ã€„Ð€€µ'€Ý are the pointed, dm one, and been and „ÃÐµÝ is perfectly okay.

Old 38-byte version:
„€€Ã€„Ð€€µ'€Ý)\ giqë¬?[ûDN>3*©è?®Ig<Ö#

Try it online. (PS: Switch the language from 05AB1E (legacy) to 05AB1E for test cases 0123456789 and @. The legacy version is faster, but it shows incorrect results for number inputs with leading zeros or single-char inputs.)
The 'backhanded' program will become:
„ÃÐµÝ q?D3èIÖ<®©>û¬i\€€„€€€€')gë[N*?g#

(Where the q exits the program and makes everything else no-ops.)
Try it online.

Surely / should be \\?

Using N>3*© instead of XU saves 2. I also feel like there should be some way do all printing in the loop, which would save even more bytes.

@Emigna Yeah, /  should have been \ .. And thanks for the -2. I indeed have the feeling it can be golfed further. It seems overly long for the base functionality of printing every 3rd value including bouncing back.

@Emigna Very ugly, but [ûDN3*©è?®IgD#<ÖNĀ*# is without the if-else beforehand, which is 2 bytes shorter than the if-else with loop. Unfortunately, we still need the q for the backhanded program, so it will be also 38 bytes. But I have the feeling that break can definitely be improved somehow keeping in mind single-char inputs, index 0, and divisibility by length-1 at the same time..

Perl 6, 101 86 bytes
Wow, -25 bytes thanks to nwellnhof by drastically improving the first program
##
{S:g/(.).?.?/$0/}o{.comb%3-1??.chop~.flip~S/.//!!$_} #
#}{ "" s( kM ro os wt  l )y.

Try it online!
I'm hoping more people take advantage of the rebound like this. The Backhanded program is
#{g.?//{o%1.o.iS/!}
{"(Mostly) works"}#_!.~l~h?-bco0?.(:
#S/).$}.m3?cpfp//$ #        .

Which comments out to just {"(Mostly) works"}.

Python 2, 130 bytes
p='r'#i  n  t  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  #
s=input();S=s+s[-2:0:-1]+s
print S[:len(~-len(s)%3and S or s):3]

Try it online!

JavaScript (ES6), 130 bytes
Early attempt. Not very satisfying.
f  =/*>  "  P  e  r  f  e  c  t  l  y     o  k  a*/y=>""+/**/(g=p=>(c=y[p])?m++%3?g(p+d):y[p+1]?c+g(p+d):c:g(p-d-d,d=-d))(m=0,d=1)

Try it online!
When the code is processed by itself, the following characters are isolated:
f  =/*>  "  P  e  r  f  e  c  t  l  y     o  k  a*/y=>""+/**/…
^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^

which gives:
f=>"Perfectly okay"//…

f  =y=> ""+(p=(e, r, f,xe, c, t, l,zy,i , o, k, a,xy/*"  / */)=>(c=y[e])?m++%3?p(e+d):y[e+1]?c+p(e+d):c:p(e+(d=-d)+d))(m=0,d=1) is 127 bytes

Runic Enchantments, 294 bytes
>; "  O  n  l  y     a     F  e  w     B  u  g  s  "  @
                                  /{\!?   =ka:{;!?=ka\
v   R                         R {{R:ak=?!\:$:'@=?!;{:/
v/?!/:$:'@=?!;}:ak= ?!;}:ak=?!\}\        }
y\=ka:L                      }{ /        }
\iuakrU      y<<              !  }}}L {{{L

Try it online!
Uncompressed (and almost readable) version:
>; "  O  n  l  y     a     F  e  w     B  u  g  s  "  @
                               ;           /                                 \
/y<<         R                         R {{R:ak=?!\:$:'@=?!;{:ak=?!\{:ak=?!\{/
RiuakrR:ak=?!/:$:'@=?!;}:ak= ?!/}:ak=?!\}\        }                ;
\y<<  U                               }{ /        }
      \                                !          L                     }}}L

Try it Online!
This...is about as close as I can get.
Compressing it further would require figuring out a way to handle the various loop swapping points without having them collide with other stuff. The first line (which is the only part needs to be passed as input to itself) is required to remain separate: the entire string can't fit on the second line without causing problems (_ for required spaces):
Needed string:
>; "  O  n  l  y  _  a  _  F  e  w  _  B  u  g  s
Best fit:
>; "  O  n  l  y  _  a  _  F  e  w/{_\!?   =ka:{;!?=ka\
Collision:                             ↑

That ? can't be moved away from the ! which itself can't be moved away from the \ and none of the allowable messages allow any of these three characters at this position.
The alternative would be to use flow redirection, but that leads to a problem on the lower line:
Last usable character:
            ↓
>"Only a Few Bugs"@
/.../
ur         }{L
              ↑
Earliest available free space:

As we have to avoid the loop switch in the main program.
Known issues:

Extremely large inputs. Due to Runic's IP stack limits, pushing very large input strings will cause the IP to expire before completing. This can be minimized by spawning additional IPs and merging them (for example, it handles abcdefghijklmnopqrstuvwxyz but not the entirety of its own source). And there's a limit regardless of how many merges occur. Can handle up to 58 bytes of input as-is (additionally, increasing the number of IPs requires figuring out how to get them to merge without using more space). Can fit two more IP entries on the loop-return line (to the right of the U on the line starting \y<< in the uncompressed version, or one left on the line above the y<< in the compressed version) raising the input max length to 78.
Input strings with spaces need to have the spaces escaped (e.g. 1\ \ 1\ \ +\ \ O\ \ @). This is a limitation of the language's input parsing.
Cannot supply inputs consisting of strings that look like integers beginning with any number of 0s (as when turned into a number on the stack, the 0 is lost). Again, limitation of the language's input parsing.

How it works
Entry:

Combine 4 instruction pointers
Read input, break into characters, append a newline, reverse, enter main loop.

Main loop (anything that pops the stack is preceded by a dup):

Print the top of the stack
Compare to newline. True: switch loops and rotate stack left twice.
Compare to @. True: terminate. (Terminate command executed)
Rotate stack right
Compare to newline. True: terminate. (Rightmost command executed)
Rotate stack right
Compare to newline. True: switch loops and rotate stack left thrice.
Rotate stack right
Return to top of loop

Secondary loop:

Identical to main loop, only switch rotate right with rotate left

Err, are you trying to create a Backhand polyglot? The second program should be the result of running the first program with itself as input. Then the result of that program (when run in your original language, Runic) should be one of the phrases. From the question,  you don't need to handle any actual Backhand instructions

Your second program doesn't print anything. It just errors

That's what I get when I apply the transformation to your original program. That should then print one of the phrases. Maybe you should have a second read of the question, or have a look at the other answers

*Tries reading it again.* ...Nope, not seeing it yet...
*Tries another time.* Oh! Christ, I did not understand it like that at all. I read it as "when your program reads its own source code as input"

@JoKing Is this right, then?

It looks right, but one of the other pointers seem to break the program

@JoKing I'll see what I can do about that (but the answer is probably not much)

@JoKing Made another edit, the second program won't run until I get Dennis to update the exe. The errors being thrown are issues with the interpreter at this point and I can't work around them within the constraints of the challenge.

Jelly, 34 bytes
JŒḄȧ`ȯ“”NNŒḄ2¡3s@”]ȧZỴḢḢ»`Qị⁸ȧ@11€

A full program or monadic link accepting a list of characters which prints or yields (respectively).
Try it online! Or see the test-suite.
The Backhand-parsed code is then:
Jȧ“N2s]Ỵ»ị@€

A full program or niladic link printing or yielding (respectively) Turing complete.
How?
JŒḄȧ`ȯ“”NNŒḄ2¡3s@”]ȧZỴḢḢ»`Qị⁸ȧ@11€ - Main Link: list of characters   e.g. 'abcd'
J                                  - range of length                      [1,2,3,4]
 ŒḄ                                - bounce                         [1,2,3,4,3,2,1]
    `                              - use as both arguments of:
   ȧ                               -   logical AND [x AND x = x]
      “”                           - literal empty list of characters
     ȯ                             - logical OR [when x is truthy: x OR y = x]
        N                          - negate  }
         N                         - negate  } together a no-op
             ¡                     - repeat this...
            2                      - ... two times:
          ŒḄ                       -   bounce                       [1,2,3,4,3,2,1,2,3,4,3,2,1,2,3,4,3,2,1,2,3,4,3,2,1]
              3                    - literal three
               s@                  - split into (threes)            [[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1]]
                 ”]                - literal ']' character
                   ȧ               - logical AND [']' is truthy so a no-op]
                    Z              - transpose                      [[1,4,1,4,1,4,1,4,1],[2,3,2,3,2,3,2,3],[3,2,3,2,3,2,3,2]]
                     Ỵ             - split at new lines [no newline characters exist in this list of ints so effectively wrap in a list]
                      Ḣ            - head [undo that wrap]
                       Ḣ           - head [get the first of the transposed split indices]
                                   -                                [1,4,1,4,1,4,1,4,1]
                         `         - use as both arguments of:
                        »          -   maximum [max(x, x) = x]
                          Q        - de-duplicate                   [1,4]
                            ⁸      - chain's left argument (the input)
                           ị       - index into it                  "ad"
                               11€ - literal eleven for €ach (of input)
                             ȧ@    - logical AND with swapped args [[11,11,...,11] is truthy]
                                   -                                "ad"
                                   - (as a full program implicit print)

the Backhand-parsed code is then:
Jȧ“N2s]Ỵ»ị@€ - Main Link: no arguments
J            - range of length (of an implicit 0, treated as [0]) -> [1]
  “N2s]Ỵ»    - compression of "Turing complete"
 ȧ           - logical AND [[1] is truthy] -> "Turing complete"
           € - for each character in the list of characters:
          @  -   with swapped arguments (an implicit 0 is on the right, so f(0, "Turing complete"))
         ị   -     index into
             - (as a full program implicit print)

source: Stack Exchange

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

sort: votes


text:
Display numbers lacking 2's
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

I assume the winning criteria is code-golf right?

Does the order matter? ('Sequence' seems to imply that it does.)

Can we output from 100 to 1 instead of 1 to 100?

Yes the order matters.

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.

Might I suggest using the Sandbox in the future to get feedback on your challenges before posting?

the shortest possible python code wins.

@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.

I added [tag:code-golf] since that seems to be the closest applicable tag for OP's intended challenge

From review queue, I think as it is the question is under-specified. If the order matters, edit that into the question. People should not need to read comments to know the challenge.

Instead of replying in the comments, [edit] the post.

Also, arbitrarily restricting the language is disallowed.

@user202729 Arbitrary restriction is unwelcome, not disallowed.

Can we print leading zeroes for any number?

@JonathanFrech Uh, that's right, it's "avoided".

May we output 0 as well? Or 0 to 99?

Pretty cool that this has a score of 22 votes

I think that this answer wins with 5 bytes

05AB1E, 6 bytes
тLʒ2å_

Try it online!
Explanation
тL       # push [1 ... 100]
  ʒ      # filter, keep only elements that
   2å_   # does not contain 2

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!

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.

Yeah, generally STDERR is ignored. Relevant meta

Some of my answers could benefit from that.

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.

+1 clever use of the arithmetic progression!!

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

This is so cool!

41 bytes using your trick if we could have a leading comma.

R, 19 bytes
grep(2,1:100,inv=T)

Try it online!

grep(2,1:100,inv=T) for 19.

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!

Inverting the regex itself is a byte shorter (in this case).

Doesn't work, still lets 2s past. You'd need ^[^2]*$ which is, um, not shorter.

What, are we supposed to check our answers now?

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

Try it online!

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

remove the brackets around the numbers. Otherwise it is fine.

@Monolica Fixed

@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

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.

? 1..100-notmatch2

@mazzy Of course, why didn't I think of that? Thanks!

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!

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'.

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.

@JonathanFrech Wow, missed that. :/ No clue where that space went! It's there in the TIO...

Haskell has notElem for not.elem, but even shorter is all(/='2').

Bash + GNU utilities, 16

1 byte saved thanks to @Dennis.

seq 100|sed /2/d

Try it online!

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.

Does . $.>\¶` work for the second stage?

@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.

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

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

Powerhsell (output does not contain null-values), 24 bytes
1..100-split'.*2.*'-ne''

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!

# Tcl, 49 bytes time {if [string f 2 [incr i]]==-1 {puts $i}} 100 — Failed outgolf!

You could replace your test with a regexp:
![regexp 2 [incr i]] for -3 bytes

@david How was it possible I didn't come with the solution suggested by you of using regular expressions? Thanks.

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.

This code is identical to answer by Digital Trauma.

oh crap, didn't see that one, even though I checked. Should I delete this since mine was posted later?

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

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

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.

I don't know if the consensus is that the Print is necessary, but who really cares, anyway.

[...] but who really cares, anyway. -- that's the spirit ...

Do \[LeftCeiling] and \[RightCeiling] really count as a single byte :)

@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.

@MishaLavrov Sounds fair ! Neat solution.

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!

55 bytes.

@JonathanFrech thanks that's clever!

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!

Welcome to PPCG! You can get it down to a round 50 by deleting the space before the if.

[print(n)for n in range(1,101)if"2"not in str(n)] works.

Alternatively, based on one of the Python 2 answers: n=17;exec("print((n>177)*10+n//9);n+=10;"*81)

@JosiahRyanW I wasn't aware of the implicit print, thanks!

It's not really "implicit printing", but rather a print statement inside a list comprehension. You still need the print statement.

@JosiahRyanW I misread your comment and saved just the list comprehension [print(n)for n in range(1,101)if"2"not in str(n)] as a one-line file, and it output the desired results when I ran it. That's what I thought was implicit printing.

@Gigaflop Ah, I get it. Still, I do find it cool that they're able to do that.

'2'in str(n)or print(n) is shorter than a comprehension guard.

@JonathanFrech Thanks for the tip!

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

Try it online!

Kotlin, 32 bytes
{(1..100).filter{'2' !in ""+it}}

Try it online!

Bash, 31 bytes
printf %d\\n {1..100}|grep -v 2

Try it online!
Thanks to Digital Trauma for short loop.

Welcome to PPCG!  How about echo $i instead of the printf?  Or even better printf %d\\n {1..100}|grep -v 2?

yeah right. i ll update my answer.

i am learning actually i don't know that much btw thanks.

Just beats my echo {1..100}|tr ' ' \\n|grep -v 2

-1 byte if you use sed /2/d instead of grep -v 2.

The entire printf can be replaced with seq 100, which delimits with newlines by default.

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.

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.

Nice use of PHP's wacky behavior to separate the numbers, lol

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));.

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?

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? :)

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.

Welcome to the site!

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

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

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.

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!

Jelly, 7 bytes
³D2eṆƲƇ

Try it online!

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)

Perl 5, 19 bytes
map{/2/||say}1..100

Try it online!

Nice, can't come to with anything more terse just yet! You can save one bute going with map/2/||say,1..100 though!

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.

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

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")

[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

You can save 1 byte by using this pattern for the for loop: for(int i=0;++i<101;)

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.

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!

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!

“All solutions to challenges should: (…) Be a serious contender for the winning criteria in use. For example, an entry to a code golf contest needs to be golfed, and an entry to a speed contest should make some attempt to be fast.” — [help/on-topic] Please try to reduce the size of your solution. With just minimal refactoring can become 68 characters long: x=0 while x<100 do x=x+1 if not string.find(x,2)then print(x)end end. There are some Tips for golfing in Lua to help you out.

Welcome to PPCG! You can golf this down to 47 bytes using a for loop and a ternary statement instead of an if

Thanks. Still trolling through that tips link to see what can apply. Tried a few things, but the online compiler didn't seem to like my attempts at brevity. There are obviously many answers here posted that were not going to be a contender (the C# is my favorite, but I like the Taxi answer as well).

Ah, most people consider code-golf a competition between submissions in the same language. While a Taxi or Shakespeare submission might appear absurdly long compared to regular programming languages, remember that they are far outgolfed by any highly focused golfing language. Hope you stick around, since there aren't that many Lua golfers :)

Thanks for the welcome. Still wondering if there isn't some way curb this even more using a goto statement. Now taking a look at your 47 byte solution...

45 if you call the method on a string literal: ("").find(x,2)

@manatwork, That's a nice trick. Feeling very humbled now....

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

Try it online!

Welcome to PPCG! You can golf this down to 49 bytes by removing some whitespace, and using the fact that do...end can be replaced by {...}: (1..100).each{|x|x.to_s.includes?('2')?0: puts x} If you use p x instead of puts x you can shave some more bytes

Im newer to crystal. So thanks, I didn't even know all that stuff!

@Dylan I would suggest to incorporate said golfing suggestions to improve your score.

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.

Pip -l, 9 8 bytes
2N_FN\,h

Attempt This Online!
Explanation
       h  Preset variable: 100
     \,   1-based range: [1 2 3 ... 100]
   FN     Filter Negated on this function (i.e. keep falsey results):
2N_        Number of 2s iN the argument
          Print the resulting list (newline-separated thanks to -l flag)

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.

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

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

I don't know much about APL (much less this specific variant), but aren't the instructions typically single bytes from a different codepage?

@Joking in this case 'codepage' is 2 bytes for one char

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

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!

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

Use globals to save one byte: TIO

Forth (gforth), 58 bytes
: f 101 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
  101 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

Pyth, 13 11 bytes
f!}`2`TS100

Try it online!
-2 with many thanks (nearly a year later!) to @ar4093
Original version:
VS*TTI!}\2`NN

Try it online!
I'm still a Pyth beginner so this could probably be improved on.
Explanation
for N in num_to_range(Psorted(times(T,T))):   # For N in range 1 to 10*10
 if Pnot(Pin("2",repr(N))):                   # If "2" is not in `N`
  imp_print(N)                                # Print N

-2 bytes by using filtering instead of a for loop: f!}\2`TS100`

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.

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%'

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.

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.

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.

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!

Can you not use || instead of ?0:?

Windows Batch, 49 48 bytes
@for /l %%G in (1,1,100)do @echo %%G|find /v "2"

Loops from 1 to 100, and for each number looped, only output those who does not contain any "2".
1 byte is saved by @Neil.

You don't need that ~ do you?

Oh! You're right. It looks like I have forgotten how to code golf.

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.

Hello and welcome to PPCG. We usually add all necessary imports to the byte count, here import Data.List. However, you can declare that your program is not written in plain Haskell, but in some variant that includes stuff by default, e.g. Haskell (lambdabot).

Additionally to what @nimi mentioned, your answer is not valid because your program lists values over 100 too, it will print two newlines after 1 and a 0 after 19.

Ruby, 33 bytes
Solution:
puts (?1..'100').reject{|x|x[?2]}

JavaScript, 57 bytes
_=>`${[...Array(101).keys()]}`.replace(/^0,|\d?2.?,/g,'')

Try it online!

Vyxal, 5 bytes
₁'2c¬

Try it Online!
Explained
₁'2c¬
₁     # push 100 to stack
 '    # filter lambda
  2c  # contains 2
    ¬ # logical NOT

use the H flag to set the stack to 100... :p

Fig, \$9\log_{256}(96)\approx\$ 7.408 bytes
Fa@2'r-2f

Try it online!
-1 or something thanks to Seggan
F         # Filter
 a@2      # range(1, 100)
    '     # by...
      -2  # Subtracting 2 from
        f # each digit
     r    # Are all truthy?

Use @2 for 100

Vyxal 3 Rj, 4 bytes
₅ᶻ2c

Try it Online!
rip -H flag

Pip, 10 bytes
Lh2N Ui|Pi

Attempt This Online!
Explanation
Flagless version, inspired by Xcali's Perl answer.
            i is preinitialized to 0
Lh          Loop 100 times:
     Ui      Increment i
  2N         Count occurrences of 2 in (the new value of) i
       |     If that is falsey (0), then
        Pi   Print i

SmileBASIC, 50 bytes
@L
N=N+1IF.>INSTR(STR$(N),"2")THEN?N
ON N>99GOTO@L

Explanation:
@LABEL
 N = N + 1
 IF 0 > INSTR(STR$(N), "2") THEN PRINT N
ON N>99 GOTO @LABEL

INSTR(STR$(N), "2") is -1 if N doesn't contain a 2.
ON ... GOTO takes a list of labels, and jumps to a label in that list corresponding to the value of an expression.
If N isn't greater than 99, N>99 returns 0 so it jumps to the 0th label, @LABEL.
Otherwise, N>99 is 1 so it tries to jump to label 1 in the list, but since the list isn't long enough, it doesn't jump and the program ends.
ON is meant to be used like switch/case, with a longer list of labels. But ON x GOTO @LABEL can be used as a shorter way of writing IF !(x) GOTO @LABEL:
IF N<=99GOTO@L
IF N<100GOTO@L
ON N>99GOTO@L

ink, 34 bytes
-(i){("{i}"!?"2"):{i}}
{i<100:->i}

Try it online!
Explanation
-(i)             // Labelled gather - keeps track of how many times it's been visited (in variable i)
{"{i}"!?"2":     // If "2" is not a substring of i...
{i}              // ...print i
}
{i<100:->i}      // If i is less than 100, go back to i.

Vim, 18 bytes/keystrokes
100o0<esc>V{g<C-a>J:g/2/d<cr>

Try it online!

C++, 84 81 bytes
-3 bytes thanks to ceilingcat
The function needs a void return value to compile with MSVC
#include<cstdio>
void f(){for(int i=0;++i<101;)i%10-2&&i/10-2&&printf("%d\n",i);}

The if read as "if the first digit isn't 2 and the second digit isn't 2"

Deadfish~
{iiiii}dc{dddd}ic{iiii}ic{dddd}dc{iiii}iic{dddd}ddc{iiii}iiic{dddd}dddc{iiii}iiiic{dddd}ddddc{iiii}iiiiic{dddd}dddddc{iiii}iiiiiic{dddd}ddddddc{iiiii}dddc{ddddd}iiic{iiii}dcdc{dddd}iic{iiii}dcc{dddd}ic{iiii}dciic{dddd}dc{iiii}dciiic{dddd}ddc{iiii}dciiiic{dddd}dddc{iiii}dciiiiic{dddd}ddddc{iiii}dciiiiiic{dddd}dddddc{iiii}dc{i}dddc{dddd}ddddddc{iiii}dc{i}ddc{ddddd}iiic{iiii}icdddc{dddd}iic{iiii}icddc{dddd}ic{iiii}icc{dddd}dc{iiii}icic{dddd}ddc{iiii}iciic{dddd}dddc{iiii}iciiic{dddd}ddddc{iiii}iciiiic{dddd}dddddc{iiii}iciiiiic{dddd}ddddddc{iiii}iciiiiiic{ddddd}iiic{iiii}iicddddc{dddd}iic{iiii}iicdddc{dddd}ic{iiii}iicdc{dddd}dc{iiii}iicc{dddd}ddc{iiii}iicic{dddd}dddc{iiii}iiciic{dddd}ddddc{iiii}iiciiic{dddd}dddddc{iiii}iiciiiic{dddd}ddddddc{iiii}iiciiiiic{ddddd}iiic{iiii}iiicdddddc{dddd}iic{iiii}iiicddddc{dddd}ic{iiii}iiicddc{dddd}dc{iiii}iiicdc{dddd}ddc{iiii}iiicc{dddd}dddc{iiii}iiicic{dddd}ddddc{iiii}iiiciic{dddd}dddddc{iiii}iiiciiic{dddd}ddddddc{iiii}iiiciiiic{ddddd}iiic{iiii}iiiicddddddc{dddd}iic{iiii}iiiicdddddc{dddd}ic{iiii}iiiicdddc{dddd}dc{iiii}iiiicddc{dddd}ddc{iiii}iiiicdc{dddd}dddc{iiii}iiiicc{dddd}ddddc{iiii}iiiicic{dddd}dddddc{iiii}iiiiciic{dddd}ddddddc{iiii}iiiiciiic{ddddd}iiic{iiii}iiiiic{d}iiic{dddd}iic{iiii}iiiiicddddddc{dddd}ic{iiii}iiiiicddddc{dddd}dc{iiii}iiiiicdddc{dddd}ddc{iiii}iiiiicddc{dddd}dddc{iiii}iiiiicdc{dddd}ddddc{iiii}iiiiicc{dddd}dddddc{iiii}iiiiicic{dddd}ddddddc{iiii}iiiiiciic{ddddd}iiic{iiii}iiiiiic{d}iic{dddd}iic{iiii}iiiiiic{d}iiic{dddd}ic{iiii}iiiiiicdddddc{dddd}dc{iiii}iiiiiicddddc{dddd}ddc{iiii}iiiiiicdddc{dddd}dddc{iiii}iiiiiicddc{dddd}ddddc{iiii}iiiiiicdc{dddd}dddddc{iiii}iiiiiicc{dddd}ddddddc{iiii}iiiiiicic{ddddd}iiic{iiiii}dddc{d}ic{dddd}iic{iiiii}dddc{d}iic{dddd}ic{iiiii}dddcddddddc{dddd}dc{iiiii}dddcdddddc{dddd}ddc{iiiii}dddcddddc{dddd}dddc{iiiii}dddcdddc{dddd}ddddc{iiiii}dddcddc{dddd}dddddc{iiiii}dddcdc{dddd}ddddddc{iiiii}dddcc{ddddd}iiic{iiii}dcdcc

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