Antecedentes

Cuando estaba en la escuela primaria, solíamos jugar un juego en la clase de matemáticas que dice lo siguiente.

Todos los niños se sientan en un gran círculo y se turnan para contar, comenzando desde 1 .

Sin embargo, se deben omitir los siguientes números mientras se cuenta:

• Números que son múltiplos de 3 .
• Números que tienen un 3 en su representación decimal.

Los primeros 15 números que los niños deberían decir son

1 2 4 5 7 8 10 11 14 16 17 19 20 22 25

Cada vez que alguien se equivoca con un número, dice un número que no está en la secuencia o se salta un número que sí, lo elimina del círculo. Esto continúa hasta que solo queda un niño.

Tarea

Eres malo en este juego, así que decides hacer trampa. Escriba un programa o una función que, dado un número de secuencia, calcule el siguiente número de secuencia.

No tiene que manejar números que no pueden representarse utilizando el tipo numérico nativo de su idioma, siempre que su programa funcione correctamente hasta la entrada 251 y que su algoritmo funcione para entradas arbitrariamente grandes.

La entrada y la salida pueden usar cualquier base conveniente.

Como debe ocultar su código, debe ser lo más breve posible. De hecho, este es el código de golf , por lo que gana el código más corto en bytes.

Casos de prueba

  1 ->   2
  2 ->   4
 11 ->  14
 22 ->  25
 29 ->  40
251 -> 254

Brachylog , 10 bytes

<.='e3:I'*

Pruébalo en línea!

Explicación

(?)<.                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

JavaScript (ES6), 30 bytes

f=n=>++n%3*!/3/.test(n)?n:f(n)

J, 24 bytes

3(]0&({$:)~e.&":+.0=|)>:

Enfoque directo que simplemente itera hacia adelante desde la entrada n hasta que encuentra el siguiente número que es válido según las reglas.

Formas cinco emoticonos, $:, :), 0=, =|, y >:.

Uso

   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

Explicación

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

Python 2, 73 66 43 bytes

Gracias a xnor por decirme que estaba siendo tonto usando 2 variables, y gracias a Mitch Schwartz también.

x=~input()
while'3'[:x%3]in`x`:x-=1
print-x

05AB1E , 11 bytes

[>Ð3ås3Ö~_#

Pruébalo en línea!

Explicación

               # 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

Perl, 19 bytes

Código de 18 bytes + 1 para -p.

++$_%3&&!/3/||redo

Uso

perl -pe '++$_%3&&!/3/||redo' <<< 8
10

perl -pe '++$_%3&&!/3/||redo' <<< 11
14

Java 8, 57 56 55 50 bytes

Gracias a @Numberknot por 1 byte Gracias a @Kevin Cruijssen por 5 bytes

i->{for(;++i%3<1|(i+"").contains("3"););return i;}

Esto es un Function<Integer, Integer>

Explicación

Implementación ingenua que simplemente se incrementa hasta alcanzar un número aceptable.

Clase de prueba

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

}

Salida de clase de prueba:

1 2 4 5 7 8 10 11 14 16

Japt, 18 bytes

°U%3*!Us f'3 ?U:ßU

Pruébelo en línea

Finalmente tengo la oportunidad de usar ß:-)

Cómo funciona

                    // 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

PowerShell v2 +, 46 bytes

for($a=$args[0]+1;$a-match3-or!($a%3)){$a++}$a

Toma entrada $args[0], agrega 1, guarda $a, inicia un forciclo. El condicional mantiene el ciclo mientras que $a-match3(coincidencia de expresiones regulares) -or $a%3es cero (el !cual es 1). El bucle simplemente se incrementa $a++. Al final del ciclo, simplemente lo colocamos $aen la tubería y la salida a través de lo implícito Write-Outputocurre al finalizar el programa.

Ejemplos

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

R, 46 bytes

n=scan()+1;while(!n%%3|grepl(3,n))n=n+1;cat(n)

Python 2, 49 44 42 bytes

f=lambda x:'3'[:~x%3]in`~x`and f(x+1)or-~x

La otra entrada de Python supera esto (editar: no más :-D), pero la publiqué porque prefiero su enfoque recursivo. Gracias a Mitch Schwarz y Erik the Golfer por ayudarme a acortar esto.

Lua, 58 Bytes

i=...+1while(i%3==0or(i..""):find"3")do i=i+1 end print(i)

Pyke, 13 bytes

Whii3%!3`i`{|

Pruébalo aquí!

              - i = input
W             - do:
 hi           -  i += 1
   i3%!       -    not (i % 3)
            | -   ^ or V
       3`i`{  -    "3" in str(i)
              - while ^

C #, 56 , 51 bytes.

¡Esto es sorprendentemente corto para una respuesta de C #!

x=>{while(++x%3<1|(x+"").Contains("3"));return x;};

Haskell, 50 48 bytes

f n=[x|x<-[n..],mod x 3>0,notElem '3'$show x]!!1

Pruébalo en Ideone. Guardado 2 bytes gracias a @Charlie Harding .

Alternativa: (50 bytes)

g=f.(+1)
f n|mod n 3<1||(elem '3'.show)n=g n|1<3=n

Pyth, 11 bytes

f&-I`T3%T3h

Pruébelo en línea: Demostración o conjunto de pruebas

Explicación:

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

GolfSharp , 43 bytes

m=>r(m,m).w(n=>n%3>0&!n.t().I("3")).a()[1];

Ruby, 47 bytes

i=gets.to_i;i while(i+=1)%3==0||"#{i}"=~/3/;p i

Realmente siento que esto se puede jugar más golf.

MATL , 14 bytes

`Qtt3\wV51-hA~

Pruébalo en línea!

Explicación

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

Laberinto , 117 102 bytes

?       """""""""""_
):_3    (         0/{!@
;  %;:}_';:_3-_10 1
"  1            %;_
""""_""""""""{;;'

Pruébalo en línea!

Labyrinth es un lenguaje de programación bidimensional basado en la pila y en los cruces, la dirección está determinada por la parte superior de la pila (lo positivo va a la derecha, lo negativo va a la izquierda, el cero va derecho). Hay dos bucles principales en estos programas. El primero modifica la entrada entera por 3 y aumenta si es 0. El segundo verifica repetidamente si el último dígito es 3 (restando 3 y modificando por 10) y luego dividiendo entre 10 para obtener un nuevo último dígito.

PHP, 60 55 54 46 bytes

Gracias a @ user59178 por eliminar algunos bytes, @AlexHowansky por un byte, @Titus por otros pocos bytes

for(;strstr($i=++$argv[1],51)|$i%3<1;);echo$i;

Llamado desde la línea de comando con -r. Método ingenuo que se repite mientras el número es múltiplo de 3, o tiene 3 en sus dígitos.

PHP, 47 41 bytes

inspirado en Xanderhall , pero la última idea finalmente justifica una respuesta propia.

while(strstr($n+=$n=&$argn%3,51));echo$n;

o

while(strpbrk($n+=$n=&$argn%3,3));echo$n;

Esto se aprovecha del hecho de que la entrada también proviene de la secuencia: para $n%3==1, el nuevo módulo es 2. Para $n%3==2, el nuevo módulo es 4-3=1. $n%3==0Nunca sucede.

Ejecutar como tubería -Ro probarlos en línea .

APL (Dyalog Unicode) , 33 28 27 19 bytes ^SBCS

1∘+⍣{('3'∊⍕⍺)<×3|⍺}

Pruébalo en línea!

-6 gracias a Adám. -8 gracias a ngn.

Vieja explicación:

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) , 23 17 bytes ^SBCS

1∘+⍣(3(×⍤|>∊⍥⍕)⊣)

Pruébalo en línea!

Gracias a Adám. -6 gracias a ngn.

Vieja explicación:

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

Perl 6 , 27 25 24 bytes

{max $_+1...{!/3/&$_%3}}

Pruébalo en línea!

Encuentra el primer número más grande que la entrada que no tiene un tres y tiene un resto cuando está modulado por 3. Esperaba hacer algo elegante con la condición, como, !/3/&*%3pero no funciona con el !.:(

Explicación:

{                      }   # 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

C, 81 bytes

f(int n){int m;l:if(++n%3){for(m=n;m>0;m/=10)if(m%10==3)goto l;return n;}goto l;}

reticular, 30 bytes

in v
?v$>1+d3,qds:3@cQm*
;\$o

Pruébalo en línea!

Explicación

1: inicialización

in v

Esto convierte la ientrada a un número n, luego baja ( v)

2: bucle

?v$>1+d3,qds:3@cQm*
   >                 go right!              [n]
    1+               add 1                  [n+1]
      d3,            duplicate and mod 3    [n+1, (n+1)%3]
         qd          reverse and duplicate  [(n+1)%3, n+1, n+1]
           s         cast to string         [(n+1)%3, n+1, `n+1`]
            :3@c     count numbers of "3"   [(n+1)%3, n+1, `n+1`.count(3)]
                Qm*  negate and rotate      [n+1, continue?]
?v                   terminate if continue
  $                  drop continue

3: final

;\$o
 \$o  drop and output
;     terminate

Lote, 93 bytes

@set/pn=
:l
@set/an+=1,r=n%%3
@if %r%==0 goto l
@if not "%n:3=%"=="%n%" goto l
@echo %n%

Toma entrada en STDIN.

CJam, 19 bytes

ri{)__3%!\`'3e=e|}g

EN LÍNEA

Explicación:

ri{)__3%!\`'3e=e|}g
r                   Get token
 i                  Convert to integer
  {              }  Block
   )                 Increment
    _                Duplicate
     _               Duplicate
      3              Push 3
       %             Modulo
        !            NOT gate
         \           Swap
          `          String representation
           '3        Push '3'
             e=      Count occurrences
               e|    OR gate
                  g While popped ToS is true

Si se pidiera una explicación menos detallada, habría hecho esto:

ri{)__3%!\`'3e=e|}g
ri                  Get integer
  {              }  Block
   )                 Increment
    __               Triplicate
      3%!            Test non-divisibility with 3
         \           Swap
          `'3e=      Count occurrences of '3' in string repr
               e|    OR gate
                  g While popped ToS is true

Pyth, 19 bytes

JhQW|!%J3/`J\3=hJ;J

Banco de pruebas

Estoy seguro de que puedo jugar golf ... es lo mismo que mi respuesta de CJam.

Explicación:

JhQW|!%J3/`J\3=hJ;J
  Q                 Evaluated input
 h                  Increment
J                   Assign J to value
       J            Variable J
        3           Value 3
      %             Modulo
     !              Logical NOT
           J        Variable J
          `         String representation
            \3      Value "3"
         /          Count occurrences
    |               Logical OR
               h    Increment
                J   Variable J
              =     Apply function then assign
                 ;  End statement block
                  J Variable J

Clojure, 73 bytes

(fn c[n](let[m(inc n)](if(or(=(rem m 3)0)(some #(=\3 %)(str m)))(c m)m)))

Se repite recíprocamente mientras nes divisible por 3, o contiene un 3 en su representación de cadena. Aunque estoy usando una recursión no optimizada, fue capaz de manejar 2999999 como entrada, por lo que debería estar bien.

Sin golf

(defn count-without-3 [n]
  (let [m (inc n)]
    (if (or (= (rem m 3) 0)
            (some #(= \3 %) (str m)))
      (count-without-3 m)
      m)))