Arka fon

İlkokuldayken, matematik dersinde şu şekilde devam eden bir oyun oynardık.

Tüm çocuklar büyük bir daireye otururlar ve 1'den başlayarak sıralamaya girerler .

Ancak, sayma sırasında aşağıdaki sayılar atlanmalıdır:

• 3'ün katları olan sayılar .
• Ondalık göstergesinde 3 olan sayılar .

Çocukların söylemesi gereken ilk 15 sayı

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

Ne zaman biri yanlış bir numara alırsa - dizilimde olmayan bir sayı söyler veya sayı atlar - çevreden kaldırılır. Bu sadece bir çocuk kalıncaya kadar devam eder.

Görev

Bu oyunda kötüsün, bu yüzden hile yapmaya karar veriyorsun. Bir dizi verilmişse, sıradaki sayıyı hesaplayan bir program veya işlev yazın.

Programınızın 251 girişine kadar doğru çalışması ve algoritmanızın isteğe bağlı olarak büyük girişler için çalışması koşuluyla, dilinizin yerel sayısal türünü kullanarak gösterilemeyen sayıları işlemeniz gerekmez .

Giriş ve çıkış herhangi bir uygun tabanı kullanabilir.

Kodunuzu gizlemeniz gerektiğinden, mümkün olduğu kadar kısa olmalıdır. Aslında, bu kod golf , yani bayttaki en kısa kod kazanır.

Test durumları

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

Brachylog , 10 bayt

<.='e3:I'*

Çevrimiçi deneyin!

açıklama

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

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

J, 24 bayt

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

N girişinden kurallar tarafından geçerli olan bir sonraki sayıyı bulana kadar ileriye doğru yinelenen düz ileri yaklaşım .

Formlar beş suratlar, $:, :), 0=, =|, ve >:.

kullanım

   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

açıklama

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 bayt

Söylediğim için xnor sayesinde 2 değişken kullanarak aptallık yaptım ve Mitch Schwartz'a da teşekkürler.

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

05AB1E , 11 bayt

[>Ð3ås3Ö~_#

Çevrimiçi deneyin!

açıklama

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

İçin 18 bayt kodu + 1 -p.

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

kullanım

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

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

Java 8, 57 56 55 50 bayt

1 byte için @Numberknot'a teşekkürler 5 byte için @Kevin Cruijssen'e teşekkürler

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

Bu bir Function<Integer, Integer>

açıklama

Kabul edilebilir bir sayıya ulaşana kadar basit bir şekilde artan saf uygulama.

Test sınıfı

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

}

Test Sınıfının Çıkışı:

1 2 4 5 7 8 10 11 14 16

Japt, 18 bayt

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

Çevrimiçi olarak test edin

Sonunda ß:-) kullanma şansım oldu

Nasıl çalışır

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

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

Girdi alır $args[0], ekler 1, kaydeder $a, bir fordöngü başlatır . Koşullu, döngünün devam etmesini sağlar $a-match3(regex eşleşmesi) -or $a%3sıfır ( !hangisi 1). Döngü basitçe artar $a++. Döngünün sonunda, sadece $aboru hattına yerleştiririz ve örtük olarak çıktı Write-Outputprogram bitiminde olur.

Örnekler

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 bayt

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

Python 2, 49 44 42 bayt

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

Diğer Python girdisi bunu yener (düzenleme: artık :-D), ancak özyinelemeli yaklaşımını tercih ettiğim için gönderdim. Mitch Schwarz ve Golfçü Erik'e bunu daha kısa yapmamda yardımcı oldukları için teşekkürler.

Lua, 58 Bayt

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

Pyke, 13 bayt

Whii3%!3`i`{|

Burada dene!

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

C #, 56 , 51 bayt.

Bu bir C # cevap için şaşırtıcı derecede kısa!

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

Haskell, 50 48 bayt

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

Ideone'da dene. @Charlie Harding sayesinde 2 bayt kaydedildi .

Alternatif: (50 bayt)

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

Pyth, 11 bayt

f&-I`T3%T3h

Çevrimiçi deneyin: Gösteri veya Test Paketi

Açıklama:

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 bayt

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

Ruby, 47 bayt

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

Bunun daha fazla golf oynayabileceğini hissediyorum.

MATL , 14 bayt

`Qtt3\wV51-hA~

Çevrimiçi deneyin!

açıklama

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

Labirent , 117 102 bayt

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

Çevrimiçi deneyin!

Labirent, iki boyutlu, yığın tabanlı bir programlama dilidir ve kavşaklarda yön, yığının tepesi tarafından belirlenir (pozitif sağa gider, negatif sola gider, sıfır düz gider). Bu programlarda iki ana döngü vardır. Birincisi, tamsayı girişini 3 ile modlar ve 0 ise artar. İkinci, son rakamın 3 olup olmadığını tekrar tekrar kontrol eder (3'ü çıkartarak ve 10'u modlayarak) ve ardından yeni bir son rakam elde etmek için 10'a böler.

PHP, 60 55 54 46 bayt

Birkaç byte'ı tıraş etmek için @ user59178, bir byte için @AlexHowansky, başka bir byte için @Titus sayesinde

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

İle komut satırından çağrıldı -r. Sayı bir çarpı ise 3 ya da rakamında 3 olan Naif yöntem.

PHP, 47 41 bayt

Xanderhall'dan esinlenilmiş , ancak en son fikir nihayetinde bir cevabı haklı çıkardı.

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

veya

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

Bu, girişin de diziden gelmesi gerçeğinden faydalanır: Çünkü $n%3==1, yeni modulo 2. Çünkü $n%3==2, yeni modulo 4-3=1. $n%3==0asla olmaz

Pipe ile çalıştırın -Rveya çevrimiçi deneyin .

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

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

Çevrimiçi deneyin!

-6 Adám'a teşekkürler. -8 ngn sayesinde.

Eski Açıklama:

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 Genişletilmiş) , 23 17 bayt ^SBCS

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

Çevrimiçi deneyin!

Adám'a teşekkürler. -6 ngn sayesinde.

Eski Açıklama:

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 bayt

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

Çevrimiçi deneyin!

Bir üç tane var ve ben gibi, koşulu ile bir şey fantezi yapmak umuyordum 3 ile moduloed zaman kalan mevcut değil girişinden daha ilk sayı daha büyük bulur !/3/&*%3ama birlikte çalışmayı değil !.:(

Açıklama:

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

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

retiküler, 30 bayt

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

Çevrimiçi deneyin!

açıklama

1: başlatma

in v

Bu, input değerini bir number'e dönüştürür , sonra gider ( v)

2: döngü

?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

Toplu iş, 93 bayt

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

STDIN'de girişi ele alır.

CJam, 19 bayt

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

İNTERNET ÜZERİNDEN

Açıklama:

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

Daha az ayrıntılı bir açıklama istenirse, bunu yapardım:

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 bayt

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

Test odası

Eminim bununla golf oynayabilirim ... CJam cevabım ile aynı.

Açıklama:

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 bayt

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

Yinelemeli olarak döngüleri döngüsel olarak n3 ile bölünebiliyor veya string gösteriminde bir 3 içeriyor. Optimize edilmemiş özyinelemeyi kullanmama rağmen, 2999999'u bir girdi olarak kullanabildi, bu nedenle sorun değil.

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