Hintergrund

Als ich in der Grundschule war, haben wir ein Mathe-Spiel gespielt, das wie folgt aussieht.

Alle Kinder sitzen in einem großen Kreis und wechseln sich ab, beginnend mit 1 .

Die folgenden Zahlen müssen jedoch beim Zählen übersprungen werden:

• Zahlen, die ein Vielfaches von 3 sind .
• Zahlen, deren Dezimalzahl eine 3 enthält .

Die ersten 15 Zahlen, die die Kinder sagen sollten, sind

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

Wenn jemand eine falsche Nummer hat - eine Nummer sagt, die nicht in der Sequenz enthalten ist, oder eine andere überspringt - wird er aus dem Kreis entfernt. Das geht so lange, bis nur noch ein Kind übrig ist.

Aufgabe

Du bist schlecht in diesem Spiel, also entscheidest du dich zu betrügen. Schreiben Sie ein Programm oder eine Funktion, die bei gegebener Nummer der Sequenz die nächste Nummer der Sequenz berechnet.

Sie müssen keine Zahlen verarbeiten, die mit dem systemeigenen numerischen Typ Ihrer Sprache nicht dargestellt werden können, sofern Ihr Programm bis zur Eingabe 251 ordnungsgemäß funktioniert und Ihr Algorithmus für beliebig große Eingaben funktioniert.

Ein- und Ausgabe können auf jeder beliebigen Basis erfolgen.

Da Sie Ihren Code verbergen müssen, muss er so kurz wie möglich sein. In der Tat ist dies Code-Golf , so dass der kürzeste Code in Bytes gewinnt.

Testfälle

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

Brachylog , 10 Bytes

<.='e3:I'*

Probieren Sie es online!

Erläuterung

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

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

J, 24 Bytes

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

Unkomplizierter Ansatz, der von Eingabe n aus nur vorwärts iteriert, bis die nächste nach den Regeln gültige Zahl gefunden wird.

Formen fünf Smileys, $:, :), 0=, =|, und >:.

Verwendungszweck

   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

Erläuterung

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

Vielen Dank an xnor, der mir gesagt hat, dass ich durch die Verwendung von 2 Variablen dumm bin, und auch an Mitch Schwartz.

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

05AB1E , 11 Bytes

[>Ð3ås3Ö~_#

Probieren Sie es online!

Erläuterung

               # 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

18 Byte Code + 1 für -p.

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

Verwendungszweck

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

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

Java 8, 57 56 55 50 Bytes

Danke an @Numberknot für 1 Byte Danke an @Kevin Cruijssen für 5 Byte

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

Das ist ein Function<Integer, Integer>

Erläuterung

Naive Implementierung, die einfach inkrementiert, bis eine akzeptable Anzahl erreicht ist.

Testklasse

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

}

Ausgabe der Testklasse:

1 2 4 5 7 8 10 11 14 16

Japt, 18 Bytes

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

Testen Sie es online

Ich habe endlich eine Chance zu nutzen ß:-)

Wie es funktioniert

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

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

Nimmt Eingaben auf $args[0], fügt hinzu 1, speichert in $a, startet eine forSchleife. Die Bedingung hält die Schleife am Laufen, während entweder $a-match3(Regex-Übereinstimmung) -or $a%3Null ist (die !davon ist 1). Die Schleife wird einfach inkrementiert $a++. Am Ende der Schleife platzieren wir sie einfach $ain der Pipeline und geben sie implizit Write-Outputnach Abschluss des Programms aus.

Beispiele

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

Der andere Python-Eintrag schlägt dies (edit: nicht mehr :-D), aber ich habe es gepostet, weil ich seinen rekursiven Ansatz eher mag. Vielen Dank an Mitch Schwarz und Erik the Golfer, die mir geholfen haben, das Ganze zu verkürzen.

Lua, 58 Bytes

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

Pyke, 13 Bytes

Whii3%!3`i`{|

Probieren Sie es hier aus!

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

C #, 56 , 51 Bytes.

Dies ist überraschend kurz für eine C # Antwort!

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

Probieren Sie es auf Ideone. 2 Bytes dank @Charlie Harding gespart .

Alternative: (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

Probieren Sie es online aus: Demo oder Test Suite

Erläuterung:

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

Ich habe wirklich das Gefühl, dass man weiter Golf spielen kann.

MATL , 14 Bytes

`Qtt3\wV51-hA~

Probieren Sie es online!

Erläuterung

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

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

Probieren Sie es online!

Labyrinth ist eine zweidimensionale, stapelbasierte Programmiersprache und an Kreuzungen wird die Richtung durch die Oberseite des Stapels bestimmt (Positiv geht nach rechts, Negativ geht nach links, Null geht geradeaus). In diesem Programm gibt es zwei Hauptschleifen. Der erste modifiziert die Ganzzahleingabe um 3 und erhöht sie um 0. Der zweite prüft wiederholt, ob die letzte Ziffer 3 ist (indem er 3 subtrahiert und durch 10 modifiziert) und dividiert dann durch 10, um eine neue letzte Ziffer zu erhalten.

PHP, 60 55 54 46 Bytes

Vielen Dank an @ user59178 für das Abschneiden einiger Bytes, @AlexHowansky für ein Byte und @Titus für ein paar weitere Bytes

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

Wird von der Kommandozeile mit aufgerufen -r. Naive Methode, die eine Schleife ausführt, während die Zahl ein Vielfaches von 3 ist oder 3 Ziffern enthält.

PHP, 47 41 Bytes

inspiriert von Xanderhall , aber die neueste Idee rechtfertigt endlich eine eigene Antwort.

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

oder

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

Dies macht sich die Tatsache zunutze, dass die Eingabe auch aus der Sequenz stammt: Denn $n%3==1das neue Modulo ist 2. Denn $n%3==2das neue Modulo ist 4-3=1. $n%3==0passiert nie.

Laufen Sie als Pipe mit -Roder probieren Sie sie online aus .

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

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

Probieren Sie es online!

-6 danke an Adám. -8 danke an ngn.

Alte Erklärung:

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 mit} 17 Bytes

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

Probieren Sie es online!

Vielen Dank an Adám. -6 danke an ngn.

Alte Erklärung:

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

Probieren Sie es online!

Findet die erste Zahl größer ist als der Eingang, der keine drei hat und hat einen Rest , wenn moduloed von 3. Ich habe gehofft , etwas Phantasie mit der Bedingung zu tun, wie , !/3/&*%3aber es funktioniert nicht mit dem !.:(

Erläuterung:

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

Netz, 30 Bytes

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

Probieren Sie es online!

Erläuterung

1: Initialisierung

in v

Dies wandelt den input in eine number um und geht dann down ( v)

2: Schleife

?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: endgültig

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

Batch, 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%

Übernimmt die Eingabe für STDIN.

CJam, 19 Bytes

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

ONLINE

Erläuterung:

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

Wenn eine weniger ausführliche Erklärung gefragt worden wäre, hätte ich das getan:

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

Testsuite

Ich bin sicher, dass ich das Golf spielen kann ... es ist das gleiche wie meine CJam-Antwort.

Erläuterung:

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

Durchläuft rekursiv eine Schleife, während ndurch 3 teilbar ist oder eine 3 in der Zeichenfolgendarstellung enthält. Obwohl ich eine nicht optimierte Rekursion verwende, konnte sie 2999999 als Eingabe verarbeiten, daher sollte dies in Ordnung sein.

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