Contexte

Quand j'étais à l'école primaire, nous jouions à un jeu en classe de mathématiques qui se déroulait comme suit.

Tous les enfants sont assis dans un grand cercle et comptent à tour de rôle, à partir de 1 .

Toutefois, les nombres suivants doivent être ignorés lors du comptage:

• Les nombres qui sont des multiples de 3 .
• Nombres qui ont un 3 dans sa représentation décimale.

Les 15 premiers chiffres que les enfants devraient dire sont

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

Chaque fois que quelqu'un se trompe dans un numéro - dit un nombre qui n'est pas dans la séquence ou saute un nombre qui est - il est retiré du cercle. Cela continue jusqu'à ce qu'il ne reste qu'un seul enfant.

Tâche

Vous êtes mauvais à ce jeu, alors vous décidez de tricher. Ecrivez un programme ou une fonction qui, à partir d'un numéro de séquence, calcule le numéro suivant de la séquence.

Vous n'avez pas à gérer des nombres qui ne peuvent pas être représentés à l'aide du type numérique natif de votre langue, à condition que votre programme fonctionne correctement jusqu'à l'entrée 251 et que votre algorithme fonctionne pour des entrées arbitrairement grandes.

L'entrée et la sortie peuvent utiliser n'importe quelle base pratique.

Puisque vous devez cacher votre code, il doit être aussi court que possible. En fait, c'est du code-golf , donc le code le plus court en octets l'emporte.

Cas de test

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

Brachylog , 10 octets

<.='e3:I'*

Essayez-le en ligne!

Explication

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

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

J, 24 octets

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

Approche directe qui consiste simplement à effectuer une itération ultérieure de l'entrée n jusqu'à ce qu'elle trouve le prochain nombre valide par les règles.

Formulaires cinq smileys, $:, :), 0=, =|et >:.

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

Explication

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 octets

Merci à xnor de m'avoir dit que j'étais ridicule en utilisant 2 variables, et également à Mitch Schwartz.

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

05AB1E , 11 octets

[>Ð3ås3Ö~_#

Essayez-le en ligne!

Explication

               # 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 octets

Code de 18 octets + 1 pour -p.

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

Usage

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

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

Java 8, 57 56 55 50 octets

Merci à @Numberknot pour 1 octet Merci à @Kevin Cruijssen pour 5 octets

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

C'est un Function<Integer, Integer>

Explication

Une implémentation naïve qui incrémente simplement jusqu'à atteindre un nombre acceptable.

Classe d'essai

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

}

Sortie de la classe de test:

1 2 4 5 7 8 10 11 14 16

Japt, 18 octets

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

Testez-le en ligne

J'ai enfin une chance d'utiliser ß:-)

Comment ça marche

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

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

Prend les entrées $args[0], ajoute 1, enregistre dans $a, démarre une forboucle. La conditionnelle maintient la boucle en cours tant que l'une $a-match3(expression régulière) -or $a%3est égale à zéro (la valeur !est la suivante 1). La boucle s'incrémente simplement $a++. À la fin de la boucle, nous plaçons simplement $ale pipeline et la sortie via implicite Write-Outputse produit à la fin du programme.

Exemples

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 octets

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

Python 2, 49 44 42 octets

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

L'autre entrée de Python bat ceci (édition: pas plus :-D), mais je l'ai postée parce que j'aime plutôt son approche récursive. Merci à Mitch Schwarz et à Erik the Golfer de m'avoir aidé à raccourcir cette étape.

Lua, 58 octets

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

Pyke, 13 octets

Whii3%!3`i`{|

Essayez-le ici!

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

C #, 56 , 51 octets.

Ceci est étonnamment court pour une réponse en C #!

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

Haskell, 50 48 octets

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

Essayez-le sur Ideone. Sauvegardé 2 octets grâce à @Charlie Harding .

Alternative: (50 octets)

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

Pyth, 11 octets

f&-I`T3%T3h

Essayez-le en ligne: démonstration ou suite de tests

Explication:

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 octets

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

Ruby, 47 octets

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

Je sens vraiment que cela peut être joué au golf plus loin.

MATL , 14 octets

`Qtt3\wV51-hA~

Essayez-le en ligne!

Explication

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

Labyrinth , 117 102 octets

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

Essayez-le en ligne!

Labyrinth est un langage de programmation bidimensionnel basé sur des piles et, aux jonctions, la direction est déterminée par le haut de la pile (le positif va à droite, le négatif à gauche, le zéro va tout droit). Il existe deux boucles principales dans ce programme. Le premier modifie l'entrée entière de 3 et s'incrémente à 0. Le second vérifie si le dernier chiffre est 3 (en soustrayant 3 et en modifiant par 10), puis en divisant par 10 pour obtenir un nouveau dernier chiffre.

PHP, 60 55 54 46 octets

Merci à @ user59178 d’avoir coupé quelques octets, à @AlexHowansky pour un octet, à @Titus pour quelques autres

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

Appelé en ligne de commande avec -r. Méthode naïve qui boucle lorsque le nombre est un multiple de 3 ou en a 3 dans ses chiffres.

PHP, 47 41 octets

inspiré par Xanderhall , mais la dernière idée justifie enfin sa propre réponse.

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

ou

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

Cela tire parti du fait que l'entrée provient également de la séquence: Pour $n%3==1, le nouveau modulo l'est 2. Car $n%3==2le nouveau modulo est 4-3=1. $n%3==0n'arrive jamais.

Exécuter en pipe -Rou essayer en ligne .

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

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

Essayez-le en ligne!

-6 grâce à Adám. -8 grâce à ngn.

Ancienne Explication:

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 ^{SBCS de} 17 octets

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

Essayez-le en ligne!

Merci à Adam. -6 grâce à ngn.

Ancienne Explication:

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 octets

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

Essayez-le en ligne!

Trouve le premier nombre plus grand que l’entrée qui n’a pas de trois et a un reste quand moduloé par 3. J'espérais faire quelque chose de fantaisie avec la condition, comme !/3/&*%3mais ça ne marche pas avec le !.:(

Explication:

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

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

réticulaire, 30 octets

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

Essayez-le en ligne!

Explication

1: initialisation

in v

Ceci convertit le isignal en umber n, puis diminue ( v)

2: boucle

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

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

Lot, 93 octets

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

Prend une entrée sur STDIN.

CJam, 19 octets

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

En ligne

Explication:

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 une explication moins verbeuse était demandée, j'aurais fait ceci:

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 octets

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

Suite de tests

Je suis sûr que je peux jouer au golf ... c'est la même chose que ma réponse à CJam.

Explication:

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 octets

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

Boucle récursive while nest divisible par 3 ou contient un 3 dans sa représentation sous forme de chaîne. Bien que j'utilise une récursion non optimisée, il a été capable de gérer 2999999 en tant qu'entrée, donc ça devrait aller.

Ungolfed

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