Latar Belakang

Ketika saya masih di sekolah dasar, kami biasa bermain game di kelas matematika yang berlangsung sebagai berikut.

Semua anak duduk dalam lingkaran besar dan bergiliran menghitung, mulai dari 1 .

Namun, angka-angka berikut harus dilewati saat menghitung:

• Angka yang merupakan kelipatan dari 3 .
• Angka yang memiliki angka 3 dalam representasi desimalnya.

15 angka pertama yang harus dikatakan anak-anak adalah

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

Setiap kali seseorang mendapatkan nomor yang salah - mengatakan angka yang tidak ada dalam urutan atau melompati angka yang ada - dia dikeluarkan dari lingkaran. Ini berlangsung sampai hanya ada satu anak yang tersisa.

Tugas

Anda buruk dalam permainan ini, jadi Anda memutuskan untuk curang. Tulis sebuah program atau fungsi yang, mengingat sejumlah urutan, menghitung jumlah urutan berikutnya.

Anda tidak harus menangani angka yang tidak dapat direpresentasikan menggunakan tipe numerik asli bahasa Anda, asalkan program Anda berfungsi dengan benar hingga input 251 dan algoritma Anda bekerja untuk input besar yang sewenang-wenang.

Input dan output dapat menggunakan basis yang nyaman.

Karena Anda harus menyembunyikan kode Anda, itu harus sesingkat mungkin. Sebenarnya, ini adalah kode-golf , jadi kode terpendek dalam byte menang.

Uji kasus

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

Brachylog , 10 byte

<.='e3:I'*

Cobalah online!

Penjelasan

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

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

Pendekatan straight-forward yang hanya beralih dari input n hingga menemukan nomor berikutnya yang valid oleh aturan.

Bentuk lima smiley, $:, :), 0=, =|, dan >:.

Pemakaian

   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

Penjelasan

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 byte

Terima kasih kepada xnor karena memberi tahu saya bahwa saya bodoh dengan menggunakan 2 variabel, dan terima kasih kepada Mitch Schwartz juga.

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

05AB1E , 11 byte

[>Ð3ås3Ö~_#

Cobalah online!

Penjelasan

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

Kode 18 byte +1 untuk -p.

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

Pemakaian

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

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

Java 8, 57 56 55 50 byte

Terima kasih kepada @Numberknot untuk 1 byte Terima kasih kepada @Kevin Cruijssen selama 5 byte

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

Ini adalah sebuah Function<Integer, Integer>

Penjelasan

Implementasi naif yang hanya menambah sampai mencapai angka yang dapat diterima.

Kelas Tes

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 dari Kelas Tes:

1 2 4 5 7 8 10 11 14 16

Japt, 18 byte

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

Uji secara online

Saya akhirnya memiliki kesempatan untuk menggunakan ß:-)

Bagaimana itu bekerja

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

Mengambil input $args[0], menambah 1, menyimpan $a, memulai satu forputaran. Kondisional membuat loop tetap berjalan sementara $a-match3(regex match) -or $a%3bernilai nol (yang !mana 1). Loopnya hanya menambah $a++. Pada akhir loop, kita cukup menempatkan $apada pipeline, dan output melalui implisit Write-Outputterjadi pada penyelesaian program.

Contohnya

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 byte

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

Python 2, 49 44 42 byte

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

Entri Python lain mengalahkan ini (edit: tidak ada lagi :-D), tapi saya mempostingnya karena saya lebih suka pendekatan rekursifnya. Terima kasih kepada Mitch Schwarz dan Erik the Pegolf karena membantu saya membuat ini lebih pendek.

Lua, 58 Bytes

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

Pyke, 13 byte

Whii3%!3`i`{|

Coba di sini!

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

C #, 56 , 51 byte.

Ini mengejutkan pendek untuk jawaban C #!

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

Haskell, 50 48 byte

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

Cobalah di Ideone. Disimpan 2 byte berkat @Charlie Harding .

Alternatif: (50 byte)

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

Pyth, 11 byte

f&-I`T3%T3h

Cobalah online: Demonstrasi atau Test Suite

Penjelasan:

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 byte

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

Ruby, 47 byte

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

Saya benar-benar merasa seperti ini bisa bermain golf lebih jauh.

MATL , 14 byte

`Qtt3\wV51-hA~

Cobalah online!

Penjelasan

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

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

Cobalah online!

Labyrinth adalah bahasa pemrograman dua dimensi berbasis stack dan di persimpangan, arah ditentukan oleh bagian atas stack (positif ke kanan, negatif ke kiri, nol ke kanan). Ada dua loop utama dalam program ini. Mod pertama memasukkan bilangan bulat dengan 3 dan menambah jika 0. Yang kedua berulang kali memeriksa apakah digit terakhir adalah 3 (dengan mengurangi 3 dan modding dengan 10) dan kemudian membaginya dengan 10 untuk mendapatkan digit terakhir yang baru.

PHP, 60 55 54 46 byte

Terima kasih kepada @ user59178 untuk mencukur beberapa byte, @AlexHowansky untuk byte, @Titus untuk beberapa byte lainnya

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

Dipanggil dari baris perintah dengan -r. Metode naif yang loop sementara angka adalah kelipatan 3, atau memiliki 3 digit.

PHP, 47 41 byte

terinspirasi oleh Xanderhall , tetapi ide terbaru akhirnya membenarkan jawaban sendiri.

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

atau

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

Ini mengambil keuntungan dari fakta bahwa input juga dari urutan: Untuk $n%3==1, modulo baru 2. Sebab $n%3==2, modulo baru adalah 4-3=1. $n%3==0tidak pernah terjadi.

Jalankan sebagai pipa dengan -Ratau coba online .

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

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

Cobalah online!

-6 terima kasih kepada Adám. -8 Terima kasih kepada ngn.

Penjelasan Lama:

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 byte ^SBCS

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

Cobalah online!

Terima kasih untuk Adám. -6 terima kasih kepada ngn.

Penjelasan Lama:

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 byte

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

Cobalah online!

Menemukan angka pertama lebih besar dari input yang tidak memiliki tiga dan sisanya ketika dimodulasi oleh 3. Saya berharap untuk melakukan sesuatu yang mewah dengan kondisinya, seperti !/3/&*%3tetapi tidak bekerja dengan !.:(

Penjelasan:

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

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 byte

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

Cobalah online!

Penjelasan

1: inisialisasi

in v

Ini mengubah input menjadi banyak n, kemudian turun ( v)

2: lingkaran

?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

Batch, 93 byte

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

Mengambil input pada STDIN.

CJam, 19 byte

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

ON LINE

Penjelasan:

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

Jika penjelasan yang kurang jelas ditanyakan, saya akan melakukan ini:

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 byte

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

Suite uji

Saya yakin saya bisa bermain golf ini ... sama dengan jawaban CJam saya.

Penjelasan:

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 byte

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

Loop rekursif sementara ndapat dibagi 3, atau berisi 3 dalam representasi string-nya. Meskipun saya menggunakan rekursi yang tidak dioptimalkan, ia mampu menangani 2999999 sebagai input, jadi itu harus ok.

Tidak disatukan

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