Lý lịch

Khi tôi còn học tiểu học, chúng tôi thường chơi một trò chơi trong lớp toán như sau.

Tất cả trẻ em ngồi trong một vòng tròn lớn và thay phiên nhau đếm, bắt đầu từ 1 .

Tuy nhiên, các số sau phải được bỏ qua trong khi đếm:

• Các số là bội số của 3 .
• Các số có 3 trong biểu diễn thập phân của nó.

15 số đầu tiên mà trẻ nên nói là

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

Bất cứ khi nào ai đó nhận được một số sai - nói một số không nằm trong chuỗi hoặc bỏ qua một số đó - anh ta sẽ bị xóa khỏi vòng tròn. Điều này diễn ra cho đến khi chỉ còn một đứa trẻ.

Bài tập, nhiệm vụ

Bạn rất tệ trong trò chơi này, vì vậy bạn quyết định gian lận. Viết chương trình hoặc hàm, cho một số thứ tự, tính toán số tiếp theo của chuỗi.

Bạn không phải xử lý các số không thể biểu diễn bằng loại số gốc của ngôn ngữ của mình, miễn là chương trình của bạn hoạt động chính xác đến đầu vào 251 và thuật toán của bạn hoạt động cho các đầu vào lớn tùy ý.

Đầu vào và đầu ra có thể sử dụng bất kỳ cơ sở thuận tiện.

Vì bạn phải che giấu mã của mình, nó phải càng ngắn càng tốt. Trong thực tế, đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ thắng.

Các trường hợp thử nghiệm

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

Brachylog , 10 byte

<.='e3:I'*

Hãy thử trực tuyến!

Giải trình

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

Phương pháp chuyển tiếp thẳng chỉ lặp đi lặp lại từ đầu vào n cho đến khi tìm thấy số tiếp theo hợp lệ theo quy tắc.

Các hình thức lăm biểu tượng mặt cười, $:, :), 0=, =|, và >:.

Sử dụng

   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

Giải trình

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

Cảm ơn xnor đã nói với tôi rằng tôi đã ngớ ngẩn khi sử dụng 2 biến và cũng nhờ Mitch Schwartz.

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

05AB1E , 11 byte

[>Ð3ås3Ö~_#

Hãy thử trực tuyến!

Giải trình

               # 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

Mã 18 byte + 1 cho -p.

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

Sử dụng

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

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

Java 8, 57 56 55 50 byte

Cảm ơn @Numberyh cho 1 byte Cảm ơn @Kevin Cruijssen cho 5 byte

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

Đây là một Function<Integer, Integer>

Giải trình

Thực hiện ngây thơ mà chỉ cần tăng cho đến khi nó đạt đến một con số chấp nhận được.

Lớp kiểm tra

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

}

Đầu ra của lớp kiểm tra:

1 2 4 5 7 8 10 11 14 16

Japt, 18 byte

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

Kiểm tra trực tuyến

Cuối cùng tôi cũng có cơ hội sử dụng ß:-)

Làm thế nào nó hoạt động

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

Đưa đầu vào $args[0], thêm 1, lưu vào $a, bắt đầu một forvòng lặp. Điều kiện giữ cho vòng lặp tiếp tục trong khi $a-match3(khớp regex) -or $a%3bằng 0 ( !trong đó là 1). Vòng lặp chỉ đơn giản là tăng lên $a++. Vào cuối vòng lặp, chúng ta chỉ cần đặt $atrên đường ống và đầu ra thông qua ngầm Write-Outputxảy ra khi hoàn thành chương trình.

Ví dụ

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

Mục nhập Python khác đánh bại điều này (chỉnh sửa: không còn nữa :-D), nhưng tôi đã đăng nó vì tôi thích cách tiếp cận đệ quy của nó. Cảm ơn Mitch Schwarz và Erik the Golfer đã giúp tôi rút ngắn lại.

Lua, 58 byte

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

Pyke, 13 byte

Whii3%!3`i`{|

Hãy thử nó ở đây!

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

C #, 56 , 51 byte.

Đây là ngắn gọn đáng ngạc nhiên cho một câu trả lời 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

Hãy thử nó trên Ideone. Đã lưu 2 byte nhờ @Charlie Harding .

Thay thế: (50 byte)

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

Bình thường, 11 byte

f&-I`T3%T3h

Dùng thử trực tuyến: Trình diễn hoặc Test Suite

Giải trình:

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

Tôi thực sự cảm thấy như thế này có thể được chơi gôn hơn nữa.

MATL , 14 byte

`Qtt3\wV51-hA~

Hãy thử trực tuyến!

Giải trình

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

Mê cung , 117 102 byte

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

Hãy thử trực tuyến!

Labyrinth là ngôn ngữ lập trình hai chiều, dựa trên ngăn xếp và tại các điểm nối, hướng được xác định bởi đỉnh của ngăn xếp (dương đi phải, âm sang trái, 0 đi thẳng). Có hai vòng lặp chính trong chương trình này. Đầu tiên sửa đổi số nguyên đầu vào 3 và tăng nếu 0. Số thứ hai liên tục kiểm tra xem chữ số cuối cùng có phải là 3 (bằng cách trừ 3 và sửa đổi 10) và sau đó chia cho 10 để có được một chữ số cuối cùng mới.

PHP, 60 55 54 46 byte

Cảm ơn @ user59178 đã loại bỏ một vài byte, @AlexHowansky cho một byte, @Titus cho một vài byte khác

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

Được gọi từ dòng lệnh với -r. Phương pháp ngây thơ lặp trong khi số là bội của 3 hoặc có 3 trong các chữ số của nó.

PHP, 47 41 byte

lấy cảm hứng từ Xanderhall , nhưng ý tưởng mới nhất cuối cùng cũng biện minh cho một câu trả lời của riêng mình.

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

hoặc là

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

Điều này tận dụng lợi thế từ thực tế là đầu vào cũng từ chuỗi: Đối với $n%3==1, modulo mới là 2. Đối với $n%3==2, modulo mới là 4-3=1. $n%3==0không bao giờ xảy ra

Chạy như ống với -Rhoặc thử chúng trực tuyến .

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

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

Hãy thử trực tuyến!

-6 cảm ơn Adám. -8 cảm ơn ngn.

Giải thích cũ:

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(×⍤|>∊⍥⍕)⊣)

Hãy thử trực tuyến!

Cảm ơn Adám. -6 cảm ơn ngn.

Giải thích cũ:

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

Hãy thử trực tuyến!

Tìm số đầu tiên lớn hơn số đầu vào không có số ba và số còn lại khi được điều chỉnh bằng 3. Tôi đã hy vọng làm được điều gì đó lạ mắt với điều kiện, giống như !/3/&*%3nhưng nó không hoạt động với !.:(

Giải trình:

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

mặt lưới, 30 byte

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

Hãy thử trực tuyến!

Giải trình

1: khởi tạo

in v

Điều này chuyển đổi các mục tiêu ithành một number, sau đó đi xuống ( v)

2: vòng lặp

?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: chung kết

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

Mẻ, 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%

Đưa đầu vào vào STDIN.

CJam, 19 byte

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

TRỰC TUYẾN

Giải trình:

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

Nếu một lời giải thích ít dài dòng hơn được hỏi, tôi sẽ làm điều này:

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

Bình thường, 19 byte

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

Bộ kiểm tra

Tôi chắc chắn rằng tôi có thể đánh gôn này ... nó giống như câu trả lời của tôi.

Giải trình:

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

Vòng lặp đệ quy trong khi n chia hết cho 3 hoặc chứa 3 trong biểu diễn chuỗi của nó. Mặc dù tôi đang sử dụng đệ quy không được tối ưu hóa, nó có thể xử lý 2999999 như một đầu vào, vì vậy nó sẽ ổn.

Ung dung

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