배경

초등학교에 다닐 때 우리는 수학 수업에서 다음과 같은 게임을했습니다.

모든 어린이는 큰 원 안에 앉아 1 부터 시작하여 차례를 세어 봅니다.

그러나 계산하는 동안 다음 숫자를 건너 뛰어야합니다.

• 3의 배수 인 숫자 .
• 10 진수 표현에 3 이있는 숫자

아이들이 말해야하는 처음 15 개의 숫자는

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

누군가 숫자가 잘못 될 때마다 (순서에 맞지 않는 숫자를 말하거나 숫자를 건너 뛰는 경우) 원에서 제거됩니다. 아이가 남을 때까지 계속됩니다.

태스크

당신은이 게임에 나쁘기 때문에 당신은 속이기로 결정합니다. 시퀀스 번호가 주어지면 다음 시퀀스 번호를 계산하는 프로그램이나 함수를 작성하십시오.

프로그램이 입력 251 까지 올바르게 작동하고 알고리즘이 임의로 큰 입력에 대해 작동하는 경우 언어의 고유 숫자 유형을 사용하여 표현할 수없는 숫자를 처리 할 필요가 없습니다 .

입출력은 편리한베이스를 사용할 수 있습니다.

코드를 숨겨야하므로 가능한 짧아야합니다. 실제로 이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다.

테스트 사례

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

Brachylog , 10 바이트

<.='e3:I'*

온라인으로 사용해보십시오!

설명

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

자바 스크립트 (ES6), 30 바이트

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

J, 24 바이트

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

규칙에 의해 유효한 다음 숫자를 찾을 때까지 입력 n 에서 앞으로 반복되는 간단한 접근 방식입니다 .

양식 오 스마일, $:, :), 0=, =|,와 >:.

용법

   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

설명

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

파이썬 2, 73 66 43 바이트

xnor에게 2 개의 변수를 사용하여 바보라고 말했고 Mitch Schwartz에게도 감사드립니다.

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

05AB1E , 11 바이트

[>Ð3ås3Ö~_#

온라인으로 사용해보십시오!

설명

               # 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

펄, 19 바이트

18 바이트 코드 + 1 -p.

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

용법

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

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

자바 8, 57 56 55 50 바이트

1 바이트의 @Numberknot 덕분에 5 바이트의 @Kevin Cruijssen 덕분에

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

이것은 Function<Integer, Integer>

설명

수용 가능한 수에 도달 할 때까지 단순히 증가하는 순진한 구현입니다.

테스트 클래스

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

}

테스트 클래스의 출력 :

1 2 4 5 7 8 10 11 14 16

apt, 18 바이트

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

온라인 테스트

나는 마침내 사용할 기회가있다 ß:-)

작동 원리

                    // 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 바이트

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

입력을 받고을 $args[0]추가 1하고에 저장 $a하고 for루프를 시작합니다 . 중 동안 조건가는 루프를 유지 $a-match3(정규식 일치) -or $a%3제로 (는 IS !어느입니다 1). 루프는 단순히 증가 $a++합니다. 루프가 끝나면 $a파이프 라인에 간단히 배치 하고 암시 적 출력 Write-Output은 프로그램 완료시 발생합니다.

예

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 바이트

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

파이썬 2, 49 44 42 바이트

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

다른 파이썬 항목은 이것을 능가합니다 (편집 : 더 이상 :-D는 아니지만). 재귀 접근 방식을 좋아하기 때문에 게시했습니다. 이것을 더 짧게 만드는 데 도움을 준 Mitch Schwarz와 골퍼 Erik에게 감사합니다.

루아, 58 바이트

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

파이크, 13 바이트

Whii3%!3`i`{|

여기 사용해보십시오!

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

C #, 56 , 51 바이트

이것은 C # 답변의 놀랍도록 짧습니다!

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

하스켈, 50 48 바이트

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

Ideone에서 사용해보십시오. @Charlie Harding 덕분에 2 바이트가 절약되었습니다 .

대안 : (50 바이트)

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

Pyth, 11 바이트

f&-I`T3%T3h

온라인으로 사용해보십시오 : 데모 또는 테스트 스위트

설명:

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 바이트

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

루비, 47 바이트

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

나는 이것이 더 골프를 칠 수 있다고 생각합니다.

MATL , 14 바이트

`Qtt3\wV51-hA~

온라인으로 사용해보십시오!

설명

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

미로 , 117102 바이트

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

온라인으로 사용해보십시오!

Labyrinth는 2 차원 스택 기반 프로그래밍 언어이며 접점에서 방향은 스택의 상단에 의해 결정됩니다 (양수는 오른쪽, 음은 왼쪽, 0은 직선). 이 프로그램에는 두 가지 주요 루프가 있습니다. 첫 번째는 정수 입력을 3 씩 수정하고 0이면 증가합니다. 두 번째는 마지막 숫자가 3인지 (3을 빼고 10을 곱하여) 반복적으로 확인한 다음 10을 나누어 새로운 마지막 숫자를 얻습니다.

PHP, 60 55 54 46 바이트

몇 바이트를 줄인 @ user59178, @AlexHowansky 한 바이트, @Titus (다른 몇 바이트)

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

로 명령 줄에서 호출됩니다 -r. 숫자가 3의 배수이거나 숫자가 3 인 동안 반복되는 순진한 방법입니다.

PHP, 47 41 바이트

Xanderhall 에서 영감을 얻었 지만 최신 아이디어는 마침내 자신의 대답을 정당화합니다.

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

또는

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

이것은 입력이 또한 시퀀스로부터 온다는 사실을 이용합니다 : For $n%3==1, new modulo is 2. 의 경우 $n%3==2새 모듈러스는 4-3=1입니다. $n%3==0절대 일어나지 않습니다.

파이프로 실행 -R하거나 온라인으로 사용해보십시오 .

APL (Dyalog Unicode) , 33 28 27 19 바이트 ^SBCS

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

온라인으로 사용해보십시오!

Adám 덕분에 -6. ngn 덕분에 -8.

이전 설명 :

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 바이트 ^SBCS

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

온라인으로 사용해보십시오!

Adám에게 감사합니다. ngn 덕분에 -6입니다.

이전 설명 :

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

펄 6 , 27 25 24 바이트

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

온라인으로 사용해보십시오!

세를 가지고 있고이 같은 조건으로 뭔가 공상을 기대하고 있었는데 (3)에 의해 moduloed 때 나머지를 가지고하지 않는 입력보다 첫 번째 숫자보다 큰 찾습니다 !/3/&*%3하지만 함께 일을하지 않습니다 !.:(

설명:

{                      }   # 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 바이트

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

망상, 30 바이트

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

온라인으로 사용해보십시오!

설명

1 : 초기화

in v

이것은 input을 number 로 변환 한 다음 내려갑니다 ( v)

2 : 루프

?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 : 최종

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

배치, 93 바이트

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

STDIN에서 입력을받습니다.

CJam, 19 바이트

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

온라인

설명:

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

덜 자세한 설명을 요청한 경우 다음을 수행했을 것입니다.

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 바이트

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

테스트 스위트

이 골프를 할 수 있다고 확신합니다 ... CJam 답변과 동일합니다.

설명:

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

클로저, 73 바이트

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

재귀 적으로 반복하는 동안 n3은 3으로 나눌 수 있거나 문자열 표현에 3을 포함합니다. 최적화되지 않은 재귀를 사용하고 있지만 입력으로 2999999를 처리 할 수있어 괜찮습니다.

언 골프

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