[Question]
  [
### Background
When I was in elementary school, we used to play a game in math class that goes as follows.
All kids sit in a big circle and take turns counting, starting from **1**. 
However, the following numbers must be skipped while counting:
* Numbers that are multiples of **3**.
* Numbers that have a **3** in its decimal representation.
The first 15 numbers the kids should say are
```
1 2 4 5 7 8 10 11 14 16 17 19 20 22 25
```
Whenever somebody gets a number wrong – says a number that isn't in the sequence or skips a number that is – he's removed from the circle. This goes on until there's only one kid left.
### Task
You're bad at this game, so you decide to cheat. Write a program or a function that, given a number of the sequence, calculates the next number of the sequence.
You don't have to handle numbers that cannot be represented using your language's native numeric type, provided that your program works correctly up to input **251** and that your algorithm works for arbitrarily large inputs.
Input and output can use any convenient base.
Since you have to conceal your code, it must be as short as possible. In fact, this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code in bytes wins.
### Test cases
```
  1 ->   2
  2 ->   4
 11 ->  14
 22 ->  25
 29 ->  40
251 -> 254
```
  
[Answer]
# [Brachylog](http://github.com/JCumin/Brachylog), 10 bytes
```
<.='e3:I'*
```
[Try it online!](http://brachylog.tryitonline.net/#code=PC49J2UzOkknKg&input=Mjk&args=Wg)
### Explanation
```
(?)<.                Output > Input
    .=               Assign a value to the Output
    . 'e3            3 cannot be an element of the Output (i.e. one of its digits)
        3:I'*(.)     There is no I such that 3*I = Output
```
[Answer]
# JavaScript (ES6), 30 bytes
```
f=n=>++n%3*!/3/.test(n)?n:f(n)
```
[Answer]
# J, 24 bytes
```
3(]0&({$:)~e.&":+.0=|)>:
```
Straight-forward approach that just iterates forward from input *n* until it finds the next number that is valid by the rules.
Forms five smileys, `$:`, `:)`, `0=`, `=|`, and `>:`.
## Usage
```
   f =: 3(]0&({$:)~e.&":+.0=|)>:
   (,.f"0) 1 2 11 22 29 251
  1   2
  2   4
 11  14
 22  25
 29  40
251 254
```
## Explanation
```
3(]0&({$:)~e.&":+.0=|)>:  Input: integer n
                      >:  Increment n
3                         The constant 3
 (                   )    Operate dyadically with 3 (LHS) and n+1 (RHS)
                    |       Take (n+1) mod 3
                  0=        Test if equal to 0
             &":            Format both 3 and n+1 as a string
           e.               Test if it contains '3' in str(n+1)
                +.          Logical OR the results from those two tests
  ]                         Right identity, gets n+1
   0&(   )~                 If the result from logical OR is true
       $:                     Call recursively on n+1
      {                       Return that as the result
                            Else act as identity function and return n+1
```
[Answer]
## Python 2, 73 66 43 bytes
Thanks to xnor for telling me I was being silly by using 2 variables, and thanks to Mitch Schwartz too. 
```
x=~input()
while'3'[:x%3]in`x`:x-=1
print-x
```
[Answer]
## Perl, 19 bytes
**18 bytes code + 1 for `-p`.**
```
++$_%3&&!/3/||redo
```
### Usage
```
perl -pe '++$_%3&&!/3/||redo' <<< 8
10
perl -pe '++$_%3&&!/3/||redo' <<< 11
14
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 11 bytes
```
[>Ð3ås3Ö~_#
```
[Try it online!](http://05ab1e.tryitonline.net/#code=Wz7DkDPDpXMzw5Z-XyM&input=Mjk)
**Explanation**
```
               # implicit input
[              # start loop
 >             # increase current number
  Ð            # triplicate
          #    # break loop IF
         _     # logical negation of
   3å          # number has one or more 3's in it
        ~      # OR
     s3Ö       # number % 3 == 0
```
[Answer]
# Java 8, ~~57~~ ~~56~~ ~~55~~ 50 bytes
*Thanks to @Numberknot for 1 byte*
*Thanks to @Kevin Cruijssen for 5 bytes*
```
i->{for(;++i%3<1|(i+"").contains("3"););return i;}
```
This is a `Function<Integer, Integer>`
**Explanation**
Naive implementation that simply increments until it reaches an acceptable number.
**Test Class**
```
public class CodeGolf {
    public static void main(String[] args) {
        Function<Integer, Integer> countingGame = i->{for(;++i%3<1|(i+"").contains("3"););return i;};
        int val = 1;
        for (int i = 0; i < 10; i++) {
            System.out.print(val + " ");
            val = countingGame.apply(val);
        }
    }
}
```
Output of Test Class:
```
1 2 4 5 7 8 10 11 14 16
```
[Answer]
# Python 2, ~~49~~ ~~44~~ 42 bytes
```
f=lambda x:'3'[:~x%3]in`~x`and f(x+1)or-~x
```
The other Python entry beats this (edit: not any more :-D), but I posted it because I rather like its recursive approach.
Thanks to Mitch Schwarz and Erik the Golfer for helping me make this shorter.
[Answer]
# Japt, 18 bytes
```
°U%3*!Us f'3 ?U:ßU
```
[**Test it online**](http://ethproductions.github.io/japt/?v=master&code=sFUlMyohVXMgZiczID9VOt9V&input=MTE=)
I finally have a chance to use `ß` :-)
### How it works
```
                    // Implicit: U = input integer
°U%3                // Increment U, and take its modulo by 3.
     !Us f'3        // Take all matches of /3/ in the number, then take logical NOT.
                    // This returns true if the number does not contain a 3.
    *               // Multiply. Returns 0 if U%3 === 0  or the number contains a 3.
             ?U     // If this is truthy (non-zero), return U.
               :ßU  // Otherwise, return the result of running the program again on U.
                    // Implicit: output last expression
```
[Answer]
## PowerShell v2+, 46 bytes
```
for($a=$args[0]+1;$a-match3-or!($a%3)){$a++}$a
```
Takes input `$args[0]`, adds `1`, saves into `$a`, starts a `for` loop. The conditional keeps the loop going while either `$a-match3` (regex match) `-or` `$a%3` is zero (the `!` of which is `1`). The loop simply increments `$a++`. At the end of the loop, we simply place `$a` on the pipeline, and output via implicit `Write-Output` happens at program completion.
### Examples
```
PS C:\Tools\Scripts\golfing> 1,2,11,22,29,33,102,251,254|%{"$_ --> "+(.\count-without-three.ps1 $_)}
1 --> 2
2 --> 4
11 --> 14
22 --> 25
29 --> 40
33 --> 40
102 --> 104
251 --> 254
254 --> 256
```
[Answer]
# R, 46 bytes
```
n=scan()+1;while(!n%%3|grepl(3,n))n=n+1;cat(n)
```
[Answer]
# Haskell, ~~50~~ 48 bytes
```
f n=[x|x<-[n..],mod x 3>0,notElem '3'$show x]!!1
```
[Try it on Ideone.](http://ideone.com/0NRlOh) Saved 2 bytes thanks to [@Charlie Harding](https://codegolf.stackexchange.com/users/15516/charlie-harding).
Alternative: (50 bytes)
```
g=f.(+1)
f n|mod n 3<1||(elem '3'.show)n=g n|1<3=n
```
[Answer]
# [Labyrinth](http://github.com/mbuettner/labyrinth), 117 102 bytes
```
?       """""""""""_
):_3    (         0/{!@
;  %;:}_';:_3-_10 1
"  1            %;_
""""_""""""""{;;'
```
[Try it online!](http://labyrinth.tryitonline.net/#code=PyAgICAgICAiIiIiIiIiIiIiIl8KKTpfMyAgICAoICAgICAgICAgMC97IUAKOyAgJTs6fV8nOzpfMy1fMTAgMQoiICAxICAgICAgICAgICAgJTtfCiIiIiJfIiIiIiIiIiJ7Ozsn&input=Mjk5)
Labyrinth is a two-dimensional, stack-based programming language and at junctions, direction is determined by the top of the stack (positive goes right, negative goes left, zero goes straight). There are two main loops in this programs. The first mods the integer input by 3 and increments if 0. The second repeatedly checks if the last digit is 3 (by subtracting 3 and modding by 10) and then dividing by 10 to get a new last digit.
[Answer]
# Lua, 58 Bytes
```
i=...+1while(i%3==0or(i..""):find"3")do i=i+1 end print(i)
```
[Answer]
## Pyke, 13 bytes
```
Whii3%!3`i`{|
```
[Try it here!](http://pyke.catbus.co.uk/?code=Whii3%25%213%60i%60%7B%7C&input=299&warnings=0)
```
              - i = input
W             - do:
 hi           -  i += 1
   i3%!       -    not (i % 3)
            | -   ^ or V
       3`i`{  -    "3" in str(i)
              - while ^
```
[Answer]
# C#, ~~56~~, 51 bytes.
This is surprisingly short for a C# answer!
```
x=>{while(++x%3<1|(x+"").Contains("3"));return x;};
```
[Answer]
# Pyth, 11 bytes
```
f&-I`T3%T3h
```
Try it online: [Demonstration](https://pyth.herokuapp.com/?code=f%26-I%60T3%25T3h&input=29&test_suite_input=1%0A2%0A11%0A22%0A29%0A251&debug=0) or [Test Suite](https://pyth.herokuapp.com/?code=f%26-I%60T3%25T3h&input=29&test_suite=1&test_suite_input=1%0A2%0A11%0A22%0A29%0A251&debug=0)
### Explanation:
```
f&-I`T3%T3hQ   implicit Q at the end
f         hQ   find the smallest integer T >= input + 1 which fulfills:
  -I`T3           T is invariant under removing the digit 3
 &                and
       %T3        T mod 3 leaves a positive remainder
```
[Answer]
# Excel, ~~79~~ 66 bytes
It [Taylor Rained](https://codegolf.stackexchange.com/questions/98366/count-without-3/246608?noredirect=1#comment552856_246608) 13 bytes
```
=MIN(LET(r,ROW(A:A),FILTER(r,ISERR(FIND(3,r))*MOD(r,3)*(r>A1)>0)))
```
Input is in the cell `A1`. Output is wherever the formula is.
The `LET()` function allows you to define variables for later reference so ti works in pairs of `variable,value`. The last argument is unpaired as it is the output.
* `r,ROW(A:A)` creates an array of 1 to whatever the last row is. In the latest version of Excel, that's 1,048,576.
* `g,FILTER(r,~*~*~>0)` takes that array and filters just for the values that aren't multiples of 3 and don't have a 3 in them. This done is by multiplying:
	+ `ISERR(FIND(3,r))` which returns TRUE if if a 3 is *not* in the number and FALSE if it *is*
	+ `MOD(r,3)` which returns 0 if it's a multiple of 3 and some positive integer if it isn't
	+ `(r>A1)` creates an array of TRUE / FALSE where the first TRUE value will be the first term that's larger than the input.
	+ When you do math on booleans, Excel uses TRUE=1 and FALSE=0 so the formula `~*~*~>0` only returns TRUE when the three pieces are TRUE (no 3 in number), some positive integer (not a multiple of 3), and TRUE (larger than the input).
* `MIN(LET(~))` finds the smallest value in the filtered array which only includes the "without 3" numbers larger than the input so the first value in the array is the next value in the sequence.
[![Screenshot](https://i.stack.imgur.com/Quvq3.png)](https://i.stack.imgur.com/Quvq3.png)
[Answer]
# [Python 3](https://docs.python.org/3/), 49 48 bytes
-3 bytes thx to The Thonnu, I missed some spaces and swapping else x+1 and else-~x allowed another space to be taken out, not
+2 bytes bc I didn't know I need to count f= on a recursive function, thx xnor :)
seems clunky but i cant see more golfs, please lmk if you see something!
```
f=lambda x:f(x+1)if x%3>1or'3'in str(x+1)else-~x
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P802JzE3KSVRocIqTaNC21AzM02hQtXYzjC/SN1YPTNPobikCCyemlOcqltX8b@gKDOvRCNNw1BTkwvGNkJiG6JIIMsYWSJzTIHq/gMA "Python 3 – Try It Online")
[Answer]
## [GolfSharp](https://github.com/timopomer/GolfSharp), 43 bytes
```
m=>r(m,m).w(n=>n%3>0&!n.t().I("3")).a()[1];
```
[Answer]
# Ruby, 47 bytes
```
i=gets.to_i;i while(i+=1)%3==0||"#{i}"=~/3/;p i
```
I really feel like this can be golfed further.
[Answer]
# [MATL](http://github.com/lmendo/MATL), 14 bytes
```
`Qtt3\wV51-hA~
```
[Try it online!](http://matl.tryitonline.net/#code=YFF0dDNcd1Y1MS1oQX4&input=Mjk)
### Explanation
```
`       % Do...while
  Q     %   Add 1. Takes input implicitly in the first iteration
  tt    %   Duplicate twice
  3\    %   Modulo 3
  wV    %   Swap, string representation
  51-   %   Subtract 51, which is ASCII for '3'
  h     %   Concatenate
  A~    %   True if any result was 0. That indicates that the number
        %   was a multiple of 3 or had some '3' digit; and thus a 
        %   new iteration is needed
```
[Answer]
# PHP, ~~60~~ ~~55~~ ~~54~~ 46 bytes
Thanks to @user59178 for shaving off a few bytes, @AlexHowansky for a byte, @Titus for another few bytes
```
for(;strstr($i=++$argv[1],51)|$i%3<1;);echo$i;
```
Called from command line with `-r`. Naive method that loops while the number is a multiple of 3, or has 3 in its digits.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 11 bytes
```
D;Æf3ḟµ‘#2ị
```
[Try it online!](https://tio.run/nexus/jelly#@@9ifbgtzfjhjvmHtj5qmKFs9HB39////40sAQ "Jelly – TIO Nexus")
### How it works
```
D;Æf3ḟµ‘#2ị  Main link. Argument: n
      µ      Combine the links to the left into a chain.
       ‘#    Execute the chain for k = n, n + 1, n + 2, ... until n + 1 matches
             were found. Yield the array of all n + 1 matches.
D            Decimal; yield the array of k's decimal digits.
  Æf         Yield the array of k's prime factors.
 ;           Concatenate both.
    3ḟ       Filter false; remove digits and factors from [3].
             This yields [3] (truthy) if neither digits nor factors contain 3,
             [] (falsy) if they do.
         2ị  Extract the second match. (The first match is n.)
```
[Answer]
# PHP, ~~47~~ 41 bytes
inspired by [Xanderhall](https://codegolf.stackexchange.com/a/98462#98462), but the latest idea finally justifies an own answer.
```
while(strstr($n+=$n=&$argn%3,51));echo$n;
```
or
```
while(strpbrk($n+=$n=&$argn%3,3));echo$n;
```
This takes advantage from the fact that the input is also from the sequence: For `$n%3==1`, the new modulo is `2`. For `$n%3==2`, the new modulo is `4-3=1`. `$n%3==0` never happens.
Run as pipe with `-R` or [try them online](http://sandbox.onlinephpfunctions.com/code/c94a70661b4b1a7f28d583f01ce72ecc287cafe4).
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~33~~ ~~28~~ ~~27~~ 19 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
```
1∘+⍣{('3'∊⍕⍺)<×3|⍺}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///3/BRxwztR72LqzXUjdUfdXQ96p36qHeXps3h6cY1QEbt/7RHbRMe9fY96pvq6f@oq/nQeuNHbROBvOAgZyAZ4uEZ/D9NwZArTcEIiA3BDBDLyBJEmBoCAA "APL (Dyalog Unicode) – Try It Online")
-6 thanks to Adám. -8 thanks to ngn.
Old Explanation:
```
1-⍨g⍣((×3|⊢)>'3'∊⍕)∘(g←+∘1)
                       +∘1  ⍝ curry + with 1, gives the increment function
                            ⍝ increments the left argument so we do not return the number itself
                    (g←   ) ⍝ assign to "g"
                   ∘        ⍝ compose g with the repeat
                 ⍕          ⍝ does parsing the argument to a string...
             '3'∊           ⍝ ...contain '3'?
        3|⊢                 ⍝ residue of a division by 3
      (×   )                ⍝ direction (0 if 0, 1 if greater, ¯1 is lower)
     (      >     )         ⍝ and not (we want the left side to be 1, the right side 0)
   g⍣                       ⍝ repeat "g" (increment) until this function is true ^
1-⍨                         ⍝ afterwards, decrement: inversed -
```
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), ~~23~~ 17 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
```
1∘+⍣(3(×⍤|>∊⍥⍕)⊣)
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/3/BRxwztR72LNYw1Dk9/1Lukxu5RR9ej3qWPeqdqPuparPk/7VHbhEe9fY/6pnr6P@pqPrTe@FHbRCAvOMgZSIZ4eAb/T1Mw5EpTMAJiQzADxDKyBBGmhgA "APL (Dyalog Extended) – Try It Online")
Thanks to Adám. -6 thanks to ngn.
Old Explanation:
```
0+⍣(3(×⍤|>∊⍥⍕)⊢)⍢(1+⊢)⊢
0                       ⍝ the left argument (⍺)
 +⍣(3(×⍤|>∊⍥⍕)⊢)        ⍝ the left function (⍺⍺)
                 (1+⊢)  ⍝ the right function (⍵⍵)
                        ⍝     (increments its argument)
                      ⊢ ⍝ the right argument (⍵)
                        ⍝     (just returns the input)
                ⍢       ⍝ under:
                        ⍝     calls (⍵⍵ ⍵) first, which increments the input
                        ⍝     also (⍵⍵ ⍺) which gives 1
                        ⍝     then calls (⍺incremented ⍺⍺ ⍵incremented)
                        ⍝     afterwards, does the opposite of ⍵⍵, and decrements the result
  ⍣                     ⍝ ⍣ fixpoint: repeats the left operation until the right side is truthy
 +                      ⍝ calls + with ⍺incremented and the input (so, 1+input)
   (3(×⍤|>∊⍥⍕)⊢)        ⍝ right operation
    3                   ⍝ on its left, "3"
              ⊢         ⍝ on its right, the current iteration
      ×⍤|               ⍝ divisibility check: × atop |
        |               ⍝     starts with 3|⊢ (residue of ⊢/3)
      ×                 ⍝     then returns the direction (0 if 0, 1 if greater, ¯1 is lower)
          ∊⍥⍕           ⍝ contains 3:
            ⍕           ⍝    stringifies both its arguments (3 and ⊢)
          ∊⍥            ⍝    checks for membership
         >              ⍝ divisibility "and not" contains 3
```
[Answer]
# Turing Machine Code, 390 bytes
```
0 * * r 0
0 _ _ l 1
1 1 2 l 2
1 2 3 r 0
1 3 4 l 2
1 4 5 l 2
1 5 6 l 2
1 6 7 l 2
1 7 8 l 2
1 8 9 l 2
1 9 0 l 1
1 * 1 l 2
2 * * l 2
2 _ _ r 3
3 1 1 r 4
3 4 4 r 4
3 7 7 r 4
3 2 2 r 5
3 5 5 r 5
3 8 8 r 5
3 _ _ l 1
4 1 1 r 5
4 4 4 r 5
4 7 7 r 5
4 2 2 r 3
4 5 5 r 3
4 8 8 r 3    
5 1 1 r 3
5 4 4 r 3
5 7 7 r 3
5 2 2 r 4
5 5 5 r 4
5 8 8 r 4    
* 0 0 r *
* 6 6 r *
* 9 9 r *
* 3 3 r 0
* _ _ * halt
```
[Try it online.](http://morphett.info/turing/turing.html?9e662757c6f814b3ceb0464e715ec3ab)
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~27 25~~ 24 bytes
```
{max $_+1...{!/3/&$_%3}}
```
[Try it online!](https://tio.run/##K0gtyjH7n1uplqZg@786N7FCQSVe21BPT69aUd9YX00lXtW4tvZ/Wn6RgkZOZl5qsaZCNRdncWKlQpqGdq5@TIq2viZX7X8FBUMFXTsFBQUjLiCGME24FAwhooZAphFE1MgUyLQEM00MuIxMwQqMTE0A "Perl 6 – Try It Online")
Finds the first number larger than the input that doesn't have a three and has a remainder when moduloed by 3. I was hoping to do something fancy with the condition, like `!/3/&*%3` but it doesn't work with the `!`. `:(`
### Explanation:
```
{                      }   # Anonymous code block
     $_+1                  # From the input+1
         ...               # Get the series
            {         }    # That ends when
             !/3/            # The number does not contain a 3
                 &           # and
                  $_%3       # The number is not divisible by 3
 max                       # And get the last element of the series
```
[Answer]
# APOL, 51 bytes
`v(0 +(⧣ 1));w(|(!(%(⁰ 3)) c(t(⁰) '3')) ∆(0));-(⁰ 1)`
[Answer]
# Swift, 84 bytes
```
func f(_ n:Int)->Int{var n=n+1;while String(n).contains("3")||n%3==0{n+=1};return n}
```
]